refactor

Author: geooo109

sqlglot/generators/duckdb.py

@@ -2352,26 +2352,13 @@ def tobinary_sql(self, expression: exp.ToBinary) -> str:
 
     @unsupported_args("format")
     def tonumber_sql(self, expression: exp.ToNumber) -> str:
-        """
-        Snowflake's TO_NUMBER without precision/scale defaults to NUMBER(38, 0),
-        which truncates decimals. The parser sets these defaults at parse time.
-        Always cast to DECIMAL(precision, scale) using the values from the AST.
-
-        Oracle's TO_NUMBER without precision/scale should convert to DOUBLE.
-        """
         precision = expression.args.get("precision")
         scale = expression.args.get("scale")
 
-        # Build DECIMAL type with precision and scale from AST
         if precision and scale:
-            # Snowflake parser ensures defaults (38, 0) are set when not specified
             decimal_type = exp.DataType.build(f"DECIMAL({precision.name}, {scale.name})")
-        elif precision is None and scale is None:
-            # Oracle or other dialects that don't set defaults - convert to DOUBLE
-            decimal_type = exp.DataType.build("DOUBLE")
         else:
-            # Fallback for partial specification
-            decimal_type = exp.DataType.build("DECIMAL(38, 0)")
+            decimal_type = exp.DataType.build("DOUBLE")
 
         return self.sql(exp.cast(expression.this, decimal_type))
 

sqlglot/generators/snowflake.py

@@ -741,39 +741,6 @@ def cast_sql(self, expression: exp.Cast, safe_prefix: t.Optional[str] = None) ->
         if expression.is_type(exp.DType.GEOMETRY):
             return self.func("TO_GEOMETRY", expression.this)
 
-        # Convert CAST to DECIMAL/NUMERIC to TO_NUMBER only for string inputs
-        # Don't convert TryCast - it's handled by trycast_sql
-        if expression.is_type(exp.DType.DECIMAL) and not isinstance(expression, exp.TryCast):
-            value = expression.this
-
-            # Annotate types if not already done
-            if value.type is None:
-                from sqlglot.optimizer.annotate_types import annotate_types
-
-                value = annotate_types(value, dialect=self.dialect)
-
-            # Only convert to TO_NUMBER for string inputs
-            if value.is_string or value.is_type(*exp.DataType.TEXT_TYPES):
-                # Extract precision and scale from DECIMAL(p, s)
-                params = expression.to.expressions or []
-                precision = (
-                    params[0].this
-                    if len(params) >= 1 and isinstance(params[0], exp.DataTypeParam)
-                    else None
-                )
-                scale = (
-                    params[1].this
-                    if len(params) >= 2 and isinstance(params[1], exp.DataTypeParam)
-                    else None
-                )
-
-                to_number = exp.ToNumber(
-                    this=value,
-                    precision=precision,
-                    scale=scale,
-                )
-                return self.tonumber_sql(to_number)
-
         return super().cast_sql(expression, safe_prefix=safe_prefix)
 
     def trycast_sql(self, expression: exp.TryCast) -> str:

sqlglot/parsers/snowflake.py

@@ -39,6 +39,26 @@ def _build_approx_top_k(args: t.List) -> exp.ApproxTopK:
     return exp.ApproxTopK.from_arg_list(args)
 
 
+def _build_to_number(args: t.List, safe: bool = False) -> exp.ToNumber:
+    second_arg = seq_get(args, 1)
+    if second_arg and second_arg.is_number:
+        fmt = None
+        precision = second_arg
+        scale = seq_get(args, 2) or exp.Literal.number(0)
+    else:
+        fmt = second_arg
+        precision = seq_get(args, 2) or exp.Literal.number(38)
+        scale = seq_get(args, 3) or exp.Literal.number(0)
+
+    return exp.ToNumber(
+        this=seq_get(args, 0),
+        format=fmt,
+        precision=precision,
+        scale=scale,
+        safe=safe,
+    )
+
+
 def _build_date_from_parts(args: t.List) -> exp.DateFromParts:
     return exp.DateFromParts(
         year=seq_get(args, 0),
@@ -623,15 +643,7 @@ class SnowflakeParser(parser.Parser):
         "TRY_TO_DATE": _build_datetime("TRY_TO_DATE", exp.DType.DATE, safe=True),
         **dict.fromkeys(
             ("TRY_TO_DECIMAL", "TRY_TO_NUMBER", "TRY_TO_NUMERIC"),
-            lambda args: exp.ToNumber(
-                this=seq_get(args, 0),
-                format=seq_get(args, 1) if len(args) in (2, 4) else None,
-                precision=(seq_get(args, 2) if len(args) in (2, 4) else seq_get(args, 1))
-                or exp.Literal.number(38),
-                scale=(seq_get(args, 3) if len(args) in (2, 4) else seq_get(args, 2))
-                or exp.Literal.number(0),
-                safe=True,
-            ),
+            lambda args: _build_to_number(args, safe=True),
         ),
         "TRY_TO_DOUBLE": lambda args: exp.ToDouble(
             this=seq_get(args, 0), format=seq_get(args, 1), safe=True
@@ -654,14 +666,7 @@ class SnowflakeParser(parser.Parser):
         "TO_DATE": _build_datetime("TO_DATE", exp.DType.DATE),
         **dict.fromkeys(
             ("TO_DECIMAL", "TO_NUMBER", "TO_NUMERIC"),
-            lambda args: exp.ToNumber(
-                this=seq_get(args, 0),
-                format=seq_get(args, 1) if len(args) in (2, 4) else None,
-                precision=(seq_get(args, 2) if len(args) in (2, 4) else seq_get(args, 1))
-                or exp.Literal.number(38),
-                scale=(seq_get(args, 3) if len(args) in (2, 4) else seq_get(args, 2))
-                or exp.Literal.number(0),
-            ),
+            lambda args: _build_to_number(args),
         ),
         "TO_TIME": _build_datetime("TO_TIME", exp.DType.TIME),
         "TO_TIMESTAMP": _build_datetime("TO_TIMESTAMP", exp.DType.TIMESTAMP),

tests/dialects/test_duckdb.py

@@ -762,37 +762,34 @@ def test_duckdb(self):
             },
         )
 
-        # TO_NUMBER transpilation from Snowflake to DuckDB
         self.validate_all(
             "SELECT CAST('12.3456' AS DECIMAL(38, 0))",
             read={
                 "snowflake": "SELECT TO_NUMBER('12.3456')",
             },
             write={
                 "duckdb": "SELECT CAST('12.3456' AS DECIMAL(38, 0))",
-                "snowflake": "SELECT TO_NUMBER('12.3456')",
             },
         )
         self.validate_all(
-            "SELECT CAST('12.3456' AS DECIMAL(10, 1))",
+            "SELECT CAST('12.3456' AS DECIMAL(10, 0))",
             read={
-                "snowflake": "SELECT TO_NUMBER('12.3456', 10, 1)",
+                "snowflake": "SELECT TO_NUMBER('12.3456', 10)",
             },
             write={
-                "duckdb": "SELECT CAST('12.3456' AS DECIMAL(10, 1))",
-                "snowflake": "SELECT TO_NUMBER('12.3456', 10, 1)",
+                "duckdb": "SELECT CAST('12.3456' AS DECIMAL(10, 0))",
             },
         )
         self.validate_all(
-            "SELECT CAST('3,741.72' AS DECIMAL(6, 2))",
+            "SELECT CAST('12.3456' AS DECIMAL(10, 2))",
             read={
-                "snowflake": "SELECT TO_DECIMAL('3,741.72', '9,999.99', 6, 2)",
+                "snowflake": "SELECT TO_NUMBER('12.3456', 10, 2)",
             },
             write={
-                "duckdb": "SELECT CAST('3,741.72' AS DECIMAL(6, 2))",
-                "snowflake": "SELECT TO_NUMBER('3,741.72', 6, 2)",  # Format is lost during transpilation
+                "duckdb": "SELECT CAST('12.3456' AS DECIMAL(10, 2))",
             },
         )
+
         self.validate_all(
             "VAR_POP(x)",
             read={