feat(snowflake)!: Transpilation support for TO_DECIMAL, TO_NUMBER, TO_NUMERIC

Author: fivetran-ashashankar

sqlglot/dialects/duckdb.py

@@ -4182,78 +4182,42 @@ def strtok_sql(self, expression: exp.Strtok) -> str:
             return self.function_fallback_sql(expression)
 
         def tonumber_sql(self, expression: exp.ToNumber) -> str:
-            # TO_NUMBER(expr) -> CAST(expr AS BIGINT)
-            # TO_NUMBER(expr, precision, scale) -> CAST(expr AS DECIMAL(precision, scale))
-            # TO_NUMBER(expr, format, precision, scale) -> CAST(REGEXP_REPLACE(expr, ...) AS DECIMAL(precision, scale))
-
             this = expression.this
             format_arg = expression.args.get("format")
             precision_arg = expression.args.get("precision")
             scale_arg = expression.args.get("scale")
 
-            # Determine if format_arg is actually a format string or precision
-            actual_precision = None
-            actual_scale = None
-            format_string = None
-
-            if format_arg:
-                if format_arg.is_string:
-                    # It's a format string
-                    format_string = format_arg.this  # Get the string value
-                    actual_precision = precision_arg
-                    actual_scale = scale_arg
-                else:
-                    # It's numeric, so it's actually the precision
-                    actual_precision = format_arg
-                    actual_scale = precision_arg
+            # Parse arguments: format_arg could be format string or precision
+            if format_arg and format_arg.is_string:
+                format_string = format_arg.this
+                precision, scale = precision_arg, scale_arg
+            else:
+                format_string = None
+                precision, scale = format_arg, precision_arg
 
-            # Process format string to build preprocessing expression
-            if format_string:
-                # Determine what characters need to be stripped based on format
-                chars_to_remove = []
-
-                # Check for common format patterns
-                format_lower = format_string.lower()
-
-                # Comma separator (9,999.99 or 999,999)
-                if "," in format_string:
-                    chars_to_remove.append(",")
-
-                # Currency symbols ($, £, €, etc.)
-                if "$" in format_string:
-                    chars_to_remove.append("$")
-                if "£" in format_string:
-                    chars_to_remove.append("£")
-                if "€" in format_string:
-                    chars_to_remove.append("€")
-                if "¥" in format_string:
-                    chars_to_remove.append("¥")
-
-                # Hexadecimal format (XXX or xxx)
-                if format_lower in ("xxx", "xxxx"):
-                    # Hexadecimal conversion: ('0x' || input)::UBIGINT::BIGINT
-                    hex_expr = exp.Cast(
-                        this=exp.Cast(
-                            this=exp.Concat(expressions=[exp.Literal.string("0x"), this]),
-                            to=exp.DataType(this=exp.DataType.Type.UBIGINT),
+            # Handle hexadecimal format
+            if format_string and format_string.lower() in ("xxx", "xxxx"):
+                return self.sql(
+                    exp.cast(
+                        exp.cast(
+                            exp.Concat(expressions=[exp.Literal.string("0x"), this]),
+                            exp.DataType.Type.UBIGINT,
                         ),
-                        to=exp.DataType(this=exp.DataType.Type.BIGINT),
+                        exp.DataType.Type.BIGINT,
+                    )
+                )
+
+            # Strip formatting characters based on format string
+            if format_string:
+                chars_to_remove = {",": ",", "$": "$", "£": "£", "€": "€", "¥": "¥"}
+                chars = [c for symbol, c in chars_to_remove.items() if symbol in format_string]
+
+                if chars:
+                    pattern = (
+                        chars[0]
+                        if len(chars) == 1
+                        else f"[{''.join(c if c not in '.^$*+?{}[]\\|()' else f'\\{c}' for c in chars)}]"
                     )
-                    return self.sql(hex_expr)
-
-                # Build REGEXP_REPLACE to strip formatting characters
-                if chars_to_remove:
-                    # Build pattern: [$,] for multiple characters
-                    if len(chars_to_remove) == 1:
-                        pattern = chars_to_remove[0]
-                    else:
-                        # Escape special regex characters
-                        escaped = [
-                            c if c not in ".^$*+?{}[]\\|()" else f"\\{c}" for c in chars_to_remove
-                        ]
-                        pattern = "[" + "".join(escaped) + "]"
-
-                    # REGEXP_REPLACE(input, pattern, '', 'g')
                     this = exp.RegexpReplace(
                         this=this,
                         expression=exp.Literal.string(pattern),
@@ -4262,44 +4226,38 @@ def tonumber_sql(self, expression: exp.ToNumber) -> str:
                     )
 
             # Determine target type
-            if actual_precision is None:
-                # No precision/scale -> BIGINT (matches NUMBER(38, 0))
-                target_type = exp.DataType(this=exp.DataType.Type.BIGINT)
-            else:
-                # Get precision value
-                if isinstance(actual_precision, exp.Literal):
-                    prec_val = int(actual_precision.to_py())
-                else:
-                    # Dynamic precision not supported
-                    self.unsupported(
-                        "TO_NUMBER with non-literal precision is not supported. "
-                        "Using DOUBLE instead of DECIMAL."
-                    )
-                    return self.sql(exp.cast(this, exp.DataType.Type.DOUBLE))
-
-                # Get scale value (default to 0)
-                if actual_scale is not None:
-                    if isinstance(actual_scale, exp.Literal):
-                        scale_val = int(actual_scale.to_py())
-                    else:
-                        self.unsupported(
-                            "TO_NUMBER with non-literal scale is not supported. "
-                            "Using DOUBLE instead of DECIMAL."
-                        )
-                        return self.sql(exp.cast(this, exp.DataType.Type.DOUBLE))
-                else:
-                    scale_val = 0
+            if precision is None:
+                return self.sql(exp.cast(this, exp.DataType.Type.BIGINT))
 
-                # Build DECIMAL(precision, scale) type
-                target_type = exp.DataType(
-                    this=exp.DataType.Type.DECIMAL,
-                    expressions=[
-                        exp.DataTypeParam(this=exp.Literal.number(prec_val)),
-                        exp.DataTypeParam(this=exp.Literal.number(scale_val)),
-                    ],
+            # Extract precision and scale values
+            if not isinstance(precision, exp.Literal):
+                self.unsupported(
+                    "TO_NUMBER with non-literal precision is not supported. Using DOUBLE instead of DECIMAL."
                 )
+                return self.sql(exp.cast(this, exp.DataType.Type.DOUBLE))
+
+            prec_val = int(precision.to_py())
 
-            return self.sql(exp.Cast(this=this, to=target_type))
+            if scale and not isinstance(scale, exp.Literal):
+                self.unsupported(
+                    "TO_NUMBER with non-literal scale is not supported. Using DOUBLE instead of DECIMAL."
+                )
+                return self.sql(exp.cast(this, exp.DataType.Type.DOUBLE))
+
+            scale_val = int(scale.to_py()) if scale else 0
+
+            return self.sql(
+                exp.cast(
+                    this,
+                    exp.DataType(
+                        this=exp.DataType.Type.DECIMAL,
+                        expressions=[
+                            exp.DataTypeParam(this=exp.Literal.number(prec_val)),
+                            exp.DataTypeParam(this=exp.Literal.number(scale_val)),
+                        ],
+                    ),
+                )
+            )
 
         def approxquantile_sql(self, expression: exp.ApproxQuantile) -> str:
             result = self.func("APPROX_QUANTILE", expression.this, expression.args.get("quantile"))