Chore(tsql)!: temporarily move VARCHAR length inference logic to Fabric

Author: georgesittas

sqlglot/dialects/fabric.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 
-from sqlglot import exp
+from sqlglot import exp, transforms
 from sqlglot.dialects.dialect import NormalizationStrategy
 from sqlglot.dialects.tsql import TSQL
 from sqlglot.tokens import TokenType
@@ -27,6 +27,27 @@ def _cap_data_type_precision(expression: exp.DataType, max_precision: int = 6) -
     )
 
 
+def _add_default_precision_to_varchar(expression: exp.Expression) -> exp.Expression:
+    """Transform function to add VARCHAR(MAX) or CHAR(MAX) for cross-dialect conversion."""
+    if (
+        isinstance(expression, exp.Create)
+        and expression.kind == "TABLE"
+        and isinstance(expression.this, exp.Schema)
+    ):
+        for column in expression.this.expressions:
+            if isinstance(column, exp.ColumnDef):
+                column_type = column.kind
+                if (
+                    isinstance(column_type, exp.DataType)
+                    and column_type.this in (exp.DataType.Type.VARCHAR, exp.DataType.Type.CHAR)
+                    and not column_type.expressions
+                ):
+                    # For transpilation, VARCHAR/CHAR without precision becomes VARCHAR(MAX)/CHAR(MAX)
+                    column_type.set("expressions", [exp.var("MAX")])
+
+    return expression
+
+
 class Fabric(TSQL):
     """
     Microsoft Fabric Data Warehouse dialect that inherits from T-SQL.
@@ -60,6 +81,29 @@ class Tokenizer(TSQL.Tokenizer):
             "UTINYINT": TokenType.UTINYINT,
         }
 
+    class Parser(TSQL.Parser):
+        def _parse_create(self) -> exp.Create | exp.Command:
+            create = super()._parse_create()
+
+            if isinstance(create, exp.Create):
+                # Transform VARCHAR/CHAR without precision to VARCHAR(1)/CHAR(1)
+                if create.kind == "TABLE" and isinstance(create.this, exp.Schema):
+                    for column in create.this.expressions:
+                        if isinstance(column, exp.ColumnDef):
+                            column_type = column.kind
+                            if (
+                                isinstance(column_type, exp.DataType)
+                                and column_type.this
+                                in (exp.DataType.Type.VARCHAR, exp.DataType.Type.CHAR)
+                                and not column_type.expressions
+                            ):
+                                # Add default precision of 1 to VARCHAR/CHAR without precision
+                                # When n isn't specified in a data definition or variable declaration statement, the default length is 1.
+                                # https://learn.microsoft.com/en-us/sql/t-sql/data-types/char-and-varchar-transact-sql?view=sql-server-ver17#remarks
+                                column_type.set("expressions", [exp.Literal.number("1")])
+
+            return create
+
     class Generator(TSQL.Generator):
         # Fabric-specific type mappings - override T-SQL types that aren't supported
         # Reference: https://learn.microsoft.com/en-us/fabric/data-warehouse/data-types
@@ -85,6 +129,11 @@ class Generator(TSQL.Generator):
             exp.DataType.Type.XML: "VARCHAR",
         }
 
+        TRANSFORMS = {
+            **TSQL.Generator.TRANSFORMS,
+            exp.Create: transforms.preprocess([_add_default_precision_to_varchar]),
+        }
+
         def datatype_sql(self, expression: exp.DataType) -> str:
             # Check if this is a temporal type that needs precision handling. Fabric limits temporal
             # types to max 6 digits precision. When no precision is specified, we default to 6 digits.

sqlglot/dialects/tsql.py

@@ -392,27 +392,6 @@ def _timestrtotime_sql(self: TSQL.Generator, expression: exp.TimeStrToTime):
     return sql
 
 
-def _add_default_precision_to_varchar(expression: exp.Expression) -> exp.Expression:
-    """Transform function to add VARCHAR(MAX) or CHAR(MAX) for cross-dialect conversion."""
-    if (
-        isinstance(expression, exp.Create)
-        and expression.kind == "TABLE"
-        and isinstance(expression.this, exp.Schema)
-    ):
-        for column in expression.this.expressions:
-            if isinstance(column, exp.ColumnDef):
-                column_type = column.kind
-                if (
-                    isinstance(column_type, exp.DataType)
-                    and column_type.this in (exp.DataType.Type.VARCHAR, exp.DataType.Type.CHAR)
-                    and not column_type.expressions
-                ):
-                    # For transpilation, VARCHAR/CHAR without precision becomes VARCHAR(MAX)/CHAR(MAX)
-                    column_type.set("expressions", [exp.var("MAX")])
-
-    return expression
-
-
 def _build_datetrunc(args: t.List) -> exp.TimestampTrunc:
     unit = seq_get(args, 0)
     this = seq_get(args, 1)
@@ -890,22 +869,6 @@ def _parse_create(self) -> exp.Create | exp.Command:
 
                     create.args["properties"].append("expressions", exp.TemporaryProperty())
 
-                # Transform VARCHAR/CHAR without precision to VARCHAR(1)/CHAR(1)
-                if create.kind == "TABLE" and isinstance(create.this, exp.Schema):
-                    for column in create.this.expressions:
-                        if isinstance(column, exp.ColumnDef):
-                            column_type = column.kind
-                            if (
-                                isinstance(column_type, exp.DataType)
-                                and column_type.this
-                                in (exp.DataType.Type.VARCHAR, exp.DataType.Type.CHAR)
-                                and not column_type.expressions
-                            ):
-                                # Add default precision of 1 to VARCHAR/CHAR without precision
-                                # When n isn't specified in a data definition or variable declaration statement, the default length is 1.
-                                # https://learn.microsoft.com/en-us/sql/t-sql/data-types/char-and-varchar-transact-sql?view=sql-server-ver17#remarks
-                                column_type.set("expressions", [exp.Literal.number("1")])
-
             return create
 
         def _parse_if(self) -> t.Optional[exp.Expression]:
@@ -1043,7 +1006,6 @@ class Generator(generator.Generator):
             exp.DateAdd: date_delta_sql("DATEADD"),
             exp.DateDiff: date_delta_sql("DATEDIFF"),
             exp.CTE: transforms.preprocess([qualify_derived_table_outputs]),
-            exp.Create: transforms.preprocess([_add_default_precision_to_varchar]),
             exp.CurrentDate: rename_func("GETDATE"),
             exp.CurrentTimestamp: rename_func("GETDATE"),
             exp.CurrentTimestampLTZ: rename_func("SYSDATETIMEOFFSET"),

tests/dialects/test_fabric.py

@@ -95,3 +95,40 @@ def test_unix_to_time(self):
             "UNIX_TO_TIME(column)",
             "DATEADD(MICROSECONDS, CAST(ROUND(column * 1e6, 0) AS BIGINT), CAST('1970-01-01' AS DATETIME2(6)))",
         )
+
+    def test_varchar_precision_inference(self):
+        # Test VARCHAR without precision conversion to VARCHAR(1)
+        self.validate_identity(
+            "CREATE TABLE t (col VARCHAR)",
+            "CREATE TABLE t (col VARCHAR(1))",
+        )
+
+        # Test VARCHAR with existing precision should remain unchanged
+        self.validate_identity("CREATE TABLE t (col VARCHAR(50))")
+
+        # Test CHAR without precision conversion to CHAR(1)
+        self.validate_identity(
+            "CREATE TABLE t (col CHAR)",
+            "CREATE TABLE t (col CHAR(1))",
+        )
+
+        # Test CHAR with existing precision should remain unchanged
+        self.validate_identity("CREATE TABLE t (col CHAR(10))")
+
+        # Test cross-dialect conversion: non-TSQL VARCHAR -> TSQL VARCHAR(MAX)
+        self.validate_all(
+            "CREATE TABLE t (col VARCHAR(MAX))",
+            read={
+                "postgres": "CREATE TABLE t (col VARCHAR)",
+                "tsql": "CREATE TABLE t (col VARCHAR(MAX))",
+            },
+        )
+
+        # Test cross-dialect conversion: non-TSQL CHAR -> TSQL CHAR(MAX)
+        self.validate_all(
+            "CREATE TABLE t (col CHAR(MAX))",
+            read={
+                "postgres": "CREATE TABLE t (col CHAR)",
+                "tsql": "CREATE TABLE t (col CHAR(MAX))",
+            },
+        )

tests/dialects/test_tsql.py

@@ -288,42 +288,6 @@ def test_tsql(self):
             "CREATE TABLE [db].[tbl] ([a] INTEGER)",
         )
 
-        # Test VARCHAR without precision conversion to VARCHAR(1)
-        self.validate_identity(
-            "CREATE TABLE t (col VARCHAR)",
-            "CREATE TABLE t (col VARCHAR(1))",
-        )
-
-        # Test VARCHAR with existing precision should remain unchanged
-        self.validate_identity("CREATE TABLE t (col VARCHAR(50))")
-
-        # Test CHAR without precision conversion to CHAR(1)
-        self.validate_identity(
-            "CREATE TABLE t (col CHAR)",
-            "CREATE TABLE t (col CHAR(1))",
-        )
-
-        # Test CHAR with existing precision should remain unchanged
-        self.validate_identity("CREATE TABLE t (col CHAR(10))")
-
-        # Test cross-dialect conversion: non-TSQL VARCHAR -> TSQL VARCHAR(MAX)
-        self.validate_all(
-            "CREATE TABLE t (col VARCHAR(MAX))",
-            read={
-                "postgres": "CREATE TABLE t (col VARCHAR)",
-                "tsql": "CREATE TABLE t (col VARCHAR(MAX))",
-            },
-        )
-
-        # Test cross-dialect conversion: non-TSQL CHAR -> TSQL CHAR(MAX)
-        self.validate_all(
-            "CREATE TABLE t (col CHAR(MAX))",
-            read={
-                "postgres": "CREATE TABLE t (col CHAR)",
-                "tsql": "CREATE TABLE t (col CHAR(MAX))",
-            },
-        )
-
         self.validate_identity("SELECT a = 1", "SELECT 1 AS a").selects[0].assert_is(
             exp.Alias
         ).args["alias"].assert_is(exp.Identifier)