polyglot-sql 0.5.3__tar.gz → 0.5.5__tar.gz

{polyglot_sql-0.5.3 → polyglot_sql-0.5.5}/Cargo.lock

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

{polyglot_sql-0.5.3 → polyglot_sql-0.5.5}/Cargo.toml

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

{polyglot_sql-0.5.3 → polyglot_sql-0.5.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyglot-sql
-Version: 0.5.3
+Version: 0.5.5
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -68,6 +68,16 @@ 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")
 ```
 
+```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]
+ast = polyglot_sql.set_limit(ast, 100)
+ast = polyglot_sql.set_offset(ast, 10)
+ast = polyglot_sql.set_order_by(ast, order_expr)
+polyglot_sql.generate(ast)
+# ["SELECT id FROM a UNION ALL SELECT id FROM b ORDER BY id LIMIT 100 OFFSET 10"]
+```
+
 ### Format Guard Behavior
 
 `format_sql` uses Rust core formatting guards with default limits:
@@ -145,16 +155,22 @@ print(analysis["cteFacts"][0]["bodySql"])           # "SELECT id, amount FROM or
 print(analysis["starProjections"][0]["expandedColumns"])  # ["id", "amount"]
 print(analysis["projections"][0]["nullability"])    # "non_null"
 print(analysis["baseTables"][0]["name"])            # "orders"
+print(analysis["baseTables"][0]["table"])           # "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
+nested CTEs, derived tables, subqueries, and set-operation branches. For
+physical relation facts, `name` remains the qualified display name while
+`catalog`, `schema`, and `table` expose parsed identifier parts. Validation
 uses broad type families, while query analysis preserves parseable detailed
 schema type strings for projection `typeHint` values. `analysis["cteFacts"]`
 reports top-level CTE definitions, `analysis["starProjections"]` records the
 original star projections and schema-expanded columns, and each projection has
 conservative `nullability`: `"non_null"`, `"nullable"`, or `"unknown"`.
+Function-like projections may include `transformFunction` with the function
+name, literal arguments, and column arguments, for example for
+`DATE_TRUNC('month', created_at)`.
 
 Validation schema dictionaries use:
 

{polyglot_sql-0.5.3/crates/polyglot-sql-python → polyglot_sql-0.5.5}/README.md

@@ -41,6 +41,16 @@ 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")
 ```
 
+```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]
+ast = polyglot_sql.set_limit(ast, 100)
+ast = polyglot_sql.set_offset(ast, 10)
+ast = polyglot_sql.set_order_by(ast, order_expr)
+polyglot_sql.generate(ast)
+# ["SELECT id FROM a UNION ALL SELECT id FROM b ORDER BY id LIMIT 100 OFFSET 10"]
+```
+
 ### Format Guard Behavior
 
 `format_sql` uses Rust core formatting guards with default limits:
@@ -118,16 +128,22 @@ print(analysis["cteFacts"][0]["bodySql"])           # "SELECT id, amount FROM or
 print(analysis["starProjections"][0]["expandedColumns"])  # ["id", "amount"]
 print(analysis["projections"][0]["nullability"])    # "non_null"
 print(analysis["baseTables"][0]["name"])            # "orders"
+print(analysis["baseTables"][0]["table"])           # "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
+nested CTEs, derived tables, subqueries, and set-operation branches. For
+physical relation facts, `name` remains the qualified display name while
+`catalog`, `schema`, and `table` expose parsed identifier parts. Validation
 uses broad type families, while query analysis preserves parseable detailed
 schema type strings for projection `typeHint` values. `analysis["cteFacts"]`
 reports top-level CTE definitions, `analysis["starProjections"]` records the
 original star projections and schema-expanded columns, and each projection has
 conservative `nullability`: `"non_null"`, `"nullable"`, or `"unknown"`.
+Function-like projections may include `transformFunction` with the function
+name, literal arguments, and column arguments, for example for
+`DATE_TRUNC('month', created_at)`.
 
 Validation schema dictionaries use:
 

{polyglot_sql-0.5.3 → polyglot_sql-0.5.5}/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.3", optional = true, default-features = false }
+polyglot-sql-function-catalogs = { path = "../polyglot-sql-function-catalogs", version = "0.5.5", optional = true, default-features = false }
 
 [dev-dependencies]
 pretty_assertions = "1.4"

{polyglot_sql-0.5.3 → polyglot_sql-0.5.5}/crates/polyglot-sql/README.md

@@ -318,6 +318,8 @@ 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.
+For physical table relations, `name` remains the qualified display name and
+`catalog`, `schema`, and `table` expose parsed identifier parts.
 `cte_facts` reports top-level CTE names, declared columns, original CTE body SQL,
 and CTE output columns. `star_projections` reports the original top-level star
 projection index, optional table qualifier, and schema-expanded columns when
@@ -353,6 +355,7 @@ assert_eq!(analysis.cte_facts[0].body_sql, "SELECT id, amount FROM orders");
 assert_eq!(analysis.star_projections[0].expanded_columns, vec!["id", "amount"]);
 assert_eq!(analysis.projections[0].nullability, ProjectionNullability::NonNull);
 assert_eq!(analysis.base_tables[0].name, "orders");
+assert_eq!(analysis.base_tables[0].table.as_deref(), Some("orders"));
 ```
 
 External JSON schemas use this shape:

polyglot_sql-0.5.5/crates/polyglot-sql/src/ast_json.rs

@@ -0,0 +1,278 @@
+//! Compatibility helpers for Expression JSON accepted at public API boundaries.
+//!
+//! The canonical AST representation is the serde JSON form of [`Expression`].
+//! Some wrappers historically exposed JavaScript values that stringify unit
+//! variants such as `Expression::Null` as `{}`. These helpers repair that
+//! narrow compatibility shape while preserving errors for unknown AST forms.
+
+use crate::expressions::Expression;
+use serde_json::{json, Value};
+
+/// Deserialize a single [`Expression`] from JSON, accepting known compatibility
+/// shapes used by SDK boundaries.
+pub fn expression_from_str(input: &str) -> Result<Expression, String> {
+    let value: Value = serde_json::from_str(input).map_err(|error| error.to_string())?;
+    expression_from_value(value)
+}
+
+/// Deserialize a list of [`Expression`] values from JSON, accepting known
+/// compatibility shapes used by SDK boundaries.
+pub fn expressions_from_str(input: &str) -> Result<Vec<Expression>, String> {
+    let value: Value = serde_json::from_str(input).map_err(|error| error.to_string())?;
+    expressions_from_value(value)
+}
+
+/// Deserialize a single [`Expression`] from a JSON value.
+pub fn expression_from_value(value: Value) -> Result<Expression, String> {
+    match serde_json::from_value::<Expression>(value.clone()) {
+        Ok(expression) => Ok(expression),
+        Err(original_error) => {
+            let mut repaired = value;
+            normalize_expression_value(&mut repaired);
+            serde_json::from_value::<Expression>(repaired)
+                .map_err(|error| format!("{error}; original error: {original_error}"))
+        }
+    }
+}
+
+/// Deserialize a list of [`Expression`] values from a JSON value.
+pub fn expressions_from_value(value: Value) -> Result<Vec<Expression>, String> {
+    match serde_json::from_value::<Vec<Expression>>(value.clone()) {
+        Ok(expressions) => Ok(expressions),
+        Err(original_error) => {
+            let mut repaired = value;
+            if let Value::Array(items) = &mut repaired {
+                for item in items {
+                    normalize_expression_value(item);
+                }
+            }
+            serde_json::from_value::<Vec<Expression>>(repaired)
+                .map_err(|error| format!("{error}; original error: {original_error}"))
+        }
+    }
+}
+
+/// Serialize an [`Expression`] through serde JSON first so wrapper layers expose
+/// canonical JSON-compatible values instead of runtime-specific JS shapes.
+pub fn expression_to_value(expression: &Expression) -> Result<Value, String> {
+    serde_json::to_value(expression).map_err(|error| error.to_string())
+}
+
+fn normalize_expression_value(value: &mut Value) {
+    match value {
+        Value::Object(map) if map.is_empty() => {
+            *value = json!({ "null": null });
+        }
+        Value::Object(map) if map.len() == 1 => {
+            let (kind, payload) = map.iter_mut().next().expect("single entry exists");
+            if kind == "null" && matches!(payload, Value::Object(inner) if inner.is_empty()) {
+                *payload = Value::Null;
+                return;
+            }
+
+            if kind == "is_null" {
+                normalize_is_null_payload(payload);
+            }
+
+            match payload {
+                Value::Object(payload_map) => normalize_struct_fields(payload_map),
+                Value::Array(items) => {
+                    for item in items {
+                        normalize_expression_value(item);
+                    }
+                }
+                _ => {}
+            }
+        }
+        Value::Object(map) => normalize_struct_fields(map),
+        Value::Array(items) => {
+            for item in items {
+                normalize_expression_value(item);
+            }
+        }
+        _ => {}
+    }
+}
+
+fn normalize_is_null_payload(payload: &mut Value) {
+    let Value::Array(items) = payload else {
+        return;
+    };
+    if items.len() != 1 {
+        return;
+    }
+
+    let mut this = items.remove(0);
+    normalize_expression_value(&mut this);
+    *payload = json!({
+        "this": this,
+        "not": false,
+        "postfix_form": false
+    });
+}
+
+fn normalize_struct_fields(map: &mut serde_json::Map<String, Value>) {
+    for (key, value) in map.iter_mut() {
+        if is_expression_array_field(key) {
+            if let Value::Array(items) = value {
+                for item in items {
+                    normalize_expression_value(item);
+                }
+                continue;
+            }
+        }
+
+        if is_expression_field(key) {
+            normalize_expression_value(value);
+        } else {
+            normalize_container_value(value);
+        }
+    }
+}
+
+fn normalize_container_value(value: &mut Value) {
+    match value {
+        Value::Object(map) => normalize_struct_fields(map),
+        Value::Array(items) => {
+            for item in items {
+                normalize_container_value(item);
+            }
+        }
+        _ => {}
+    }
+}
+
+fn is_expression_field(key: &str) -> bool {
+    matches!(
+        key,
+        "this"
+            | "left"
+            | "right"
+            | "low"
+            | "high"
+            | "expression"
+            | "condition"
+            | "query"
+            | "unnest"
+            | "on"
+            | "prewhere"
+            | "where"
+            | "where_clause"
+            | "having"
+            | "qualify"
+            | "source"
+            | "body"
+            | "default"
+            | "true_value"
+            | "false_value"
+            | "else_result"
+            | "target"
+            | "format"
+            | "limit"
+            | "offset"
+    )
+}
+
+fn is_expression_array_field(key: &str) -> bool {
+    matches!(
+        key,
+        "expressions"
+            | "args"
+            | "columns"
+            | "values"
+            | "partition_by"
+            | "order_by"
+            | "group_by"
+            | "distinct_on"
+            | "limit_by"
+            | "settings"
+            | "for_xml"
+            | "for_json"
+            | "exclude"
+            | "hints"
+            | "on_columns"
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::expressions::Expression;
+
+    fn column_json(name: &str) -> Value {
+        json!({
+            "column": {
+                "name": {
+                    "name": name,
+                    "quoted": false,
+                    "trailing_comments": [],
+                    "span": null
+                },
+                "table": null,
+                "join_mark": false,
+                "trailing_comments": [],
+                "span": null,
+                "inferred_type": null
+            }
+        })
+    }
+
+    #[test]
+    fn expression_from_value_accepts_legacy_empty_object_as_null() {
+        assert!(matches!(
+            expression_from_value(json!({})).expect("empty object should become NULL"),
+            Expression::Null(_)
+        ));
+    }
+
+    #[test]
+    fn expression_from_value_accepts_empty_null_payload() {
+        assert!(matches!(
+            expression_from_value(json!({ "null": {} })).expect("empty null payload should work"),
+            Expression::Null(_)
+        ));
+    }
+
+    #[test]
+    fn expression_from_value_repairs_nested_null_expression_fields() {
+        let expression = expression_from_value(json!({
+            "between": {
+                "this": column_json("created_at"),
+                "low": { "literal": { "literal_type": "string", "value": "2024-01-01" } },
+                "high": {},
+                "not": false,
+                "symmetric": null
+            }
+        }))
+        .expect("between high bound should be repaired");
+
+        match expression {
+            Expression::Between(between) => assert!(matches!(between.high, Expression::Null(_))),
+            other => panic!("expected between expression, got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn expression_from_value_accepts_is_null_array_shorthand() {
+        let expression = expression_from_value(json!({
+            "is_null": [column_json("deleted_at")]
+        }))
+        .expect("is_null shorthand should be repaired");
+
+        match expression {
+            Expression::IsNull(is_null) => {
+                assert!(!is_null.not);
+                assert!(!is_null.postfix_form);
+                assert!(matches!(is_null.this, Expression::Column(_)));
+            }
+            other => panic!("expected is_null expression, got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn expression_from_value_keeps_unknown_ast_as_error() {
+        let error = expression_from_value(json!({ "not_a_real_expression": {} }))
+            .expect_err("unknown expression should stay invalid");
+        assert!(error.contains("not_a_real_expression"));
+    }
+}

{polyglot_sql-0.5.3 → polyglot_sql-0.5.5}/crates/polyglot-sql/src/ast_transforms.rs

@@ -98,33 +98,108 @@ pub fn remove_where(expr: Expression) -> Expression {
 }
 
 // ---------------------------------------------------------------------------
-// LIMIT / OFFSET
+// LIMIT / OFFSET / ORDER BY
 // ---------------------------------------------------------------------------
 
-/// Set the LIMIT on a SELECT.
+/// Set the LIMIT on a SELECT or set operation.
 pub fn set_limit(expr: Expression, limit: usize) -> Expression {
-    if let Expression::Select(mut sel) = expr {
-        sel.limit = Some(Limit {
-            this: Expression::number(limit as i64),
-            percent: false,
-            comments: Vec::new(),
-        });
-        Expression::Select(sel)
-    } else {
-        expr
+    set_limit_expr(expr, Expression::number(limit as i64))
+}
+
+/// 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,
     }
 }
 
-/// Set the OFFSET on a SELECT.
+/// Set the OFFSET on a SELECT or set operation.
 pub fn set_offset(expr: Expression, offset: usize) -> Expression {
-    if let Expression::Select(mut sel) = expr {
-        sel.offset = Some(Offset {
-            this: Expression::number(offset as i64),
-            rows: None,
-        });
-        Expression::Select(sel)
-    } else {
-        expr
+    set_offset_expr(expr, Expression::number(offset as i64))
+}
+
+/// 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,
+    }
+}
+
+/// Set the ORDER BY clause on a SELECT or set operation.
+///
+/// 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),
     }
 }
 
@@ -608,6 +683,14 @@ mod tests {
         assert!(sql.contains("LIMIT 10"), "Expected LIMIT in: {}", sql);
     }
 
+    #[test]
+    fn test_set_limit_on_set_operation() {
+        let expr = parse_one("SELECT a FROM t UNION ALL SELECT a FROM u");
+        let result = set_limit(expr, 10);
+        let sql = result.sql();
+        assert_eq!(sql, "SELECT a FROM t UNION ALL SELECT a FROM u LIMIT 10");
+    }
+
     #[test]
     fn test_set_offset() {
         let expr = parse_one("SELECT a FROM t");
@@ -616,6 +699,22 @@ mod tests {
         assert!(sql.contains("OFFSET 5"), "Expected OFFSET in: {}", sql);
     }
 
+    #[test]
+    fn test_set_offset_on_set_operation() {
+        let expr = parse_one("SELECT a FROM t UNION ALL SELECT a FROM u");
+        let result = set_offset(expr, 5);
+        let sql = result.sql();
+        assert_eq!(sql, "SELECT a FROM t UNION ALL SELECT a FROM u OFFSET 5");
+    }
+
+    #[test]
+    fn test_set_order_by_on_set_operation() {
+        let expr = parse_one("SELECT a FROM t UNION ALL SELECT a FROM u");
+        let result = set_order_by(expr, vec![Expression::column("a")]);
+        let sql = result.sql();
+        assert_eq!(sql, "SELECT a FROM t UNION ALL SELECT a FROM u ORDER BY a");
+    }
+
     #[test]
     fn test_remove_limit_offset() {
         let expr = parse_one("SELECT a FROM t LIMIT 10 OFFSET 5");

{polyglot_sql-0.5.3 → polyglot_sql-0.5.5}/crates/polyglot-sql/src/builder.rs

@@ -134,6 +134,27 @@ fn builder_table_ref(name: &str) -> TableRef {
 /// assert_eq!(c.to_sql(), "users.name");
 /// ```
 pub fn col(name: &str) -> Expr {
+    let parts: Vec<&str> = name.split('.').collect();
+    if parts.len() >= 3 && parts.iter().all(|part| !part.is_empty()) {
+        let mut expr = Expression::boxed_column(Column {
+            name: builder_identifier(parts[1]),
+            table: Some(builder_identifier(parts[0])),
+            join_mark: false,
+            trailing_comments: Vec::new(),
+            span: None,
+            inferred_type: None,
+        });
+
+        for field in &parts[2..] {
+            expr = Expression::Dot(Box::new(DotAccess {
+                this: expr,
+                field: builder_identifier(field),
+            }));
+        }
+
+        return Expr(expr);
+    }
+
     if let Some((table, column)) = name.rsplit_once('.') {
         Expr(Expression::boxed_column(Column {
             name: builder_identifier(column),
@@ -2891,6 +2912,12 @@ mod tests {
         assert_eq!(sql, "SELECT u.id, u.name FROM users");
     }
 
+    #[test]
+    fn test_nested_dot_column() {
+        let sql = select([col("t.s.f")]).from("users").to_sql();
+        assert_eq!(sql, "SELECT t.s.f FROM users");
+    }
+
     #[test]
     fn test_not_condition() {
         let sql = select(["id"])

{polyglot_sql-0.5.3 → polyglot_sql-0.5.5}/crates/polyglot-sql/src/dialects/tsql.rs

@@ -36,6 +36,8 @@ impl DialectImpl for TSQLDialect {
         config.identifiers.insert('[', ']');
         // SQL Server also supports double quotes (when QUOTED_IDENTIFIER is ON)
         config.identifiers.insert('"', '"');
+        // SQL Server uses 0x-prefixed binary/varbinary hex literals.
+        config.hex_number_strings = true;
         config
     }
 

{polyglot_sql-0.5.3 → polyglot_sql-0.5.5}/crates/polyglot-sql/src/generator.rs

@@ -14733,8 +14733,13 @@ impl Generator {
                 }
             }
             Literal::HexString(h) => {
-                // Most dialects use lowercase x'...' for hex literals; Spark/Databricks/Teradata use uppercase X'...'
+                // Most dialects use lowercase x'...' for hex literals.
                 match self.config.dialect {
+                    Some(DialectType::TSQL) | Some(DialectType::Fabric) => {
+                        self.write("0x");
+                        self.write(h);
+                        return Ok(());
+                    }
                     Some(DialectType::Spark)
                     | Some(DialectType::Databricks)
                     | Some(DialectType::Teradata) => self.write("X'"),