fix(databricks)!: transpile TRY_DIVIDE to/from other dialects [CLAUDE] (#7489)

Databricks' TRY_DIVIDE(a, b) returns NULL on division by zero. It is
now mapped to exp.SafeDivide, which already has the correct semantics
and generates appropriate SQL for all target dialects.

Closes #7312

Author: baruchoxman

sqlglot-integration-tests

@@ -3414,6 +3414,21 @@ def right_sql(self, expression: exp.Right) -> str:
     def rtrimmedlength_sql(self, expression: exp.RtrimmedLength) -> str:
         return self.func("LENGTH", exp.Trim(this=expression.this, position="TRAILING"))
 
+    def stuff_sql(self, expression: exp.Stuff) -> str:
+        base = expression.this
+        start = expression.args["start"]
+        length = expression.args["length"]
+        insertion = expression.expression
+        left = exp.Substring(
+            this=base.copy(),
+            start=exp.Literal.number(1),
+            length=start.copy() - exp.Literal.number(1),
+        )
+        right = exp.Substring(this=base.copy(), start=start.copy() + length.copy())
+        return self.sql(
+            exp.DPipe(this=exp.DPipe(this=left, expression=insertion), expression=right)
+        )
+
     def rand_sql(self, expression: exp.Rand) -> str:
         seed = expression.this
         if seed is not None:

sqlglot/generators/duckdb.py

@@ -119,6 +119,7 @@ class SparkGenerator(Spark2Generator):
                 f"PARTITIONED BY {self.wrap(self.expressions(sqls=[_normalize_partition(e) for e in e.this.expressions], skip_first=True))}"
             ),
             exp.SafeAdd: rename_func("TRY_ADD"),
+            exp.SafeDivide: rename_func("TRY_DIVIDE"),
             exp.SafeMultiply: rename_func("TRY_MULTIPLY"),
             exp.SafeSubtract: rename_func("TRY_SUBTRACT"),
             exp.StartsWith: rename_func("STARTSWITH"),

sqlglot/generators/spark.py

@@ -87,6 +87,7 @@ class SparkParser(Spark2Parser):
         "TIMESTAMPADD": _build_dateadd,
         "TIMESTAMPDIFF": build_date_delta(exp.TimestampDiff),
         "TRY_ADD": exp.SafeAdd.from_arg_list,
+        "TRY_DIVIDE": exp.SafeDivide.from_arg_list,
         "TRY_MULTIPLY": exp.SafeMultiply.from_arg_list,
         "TRY_SUBTRACT": exp.SafeSubtract.from_arg_list,
         "DATEDIFF": _build_datediff,

sqlglot/parsers/spark.py

@@ -1768,8 +1768,8 @@ def test_bigquery(self):
                 "trino": "IF(y <> 0, CAST(x AS DOUBLE) / y, NULL)",
                 "hive": "IF(y <> 0, x / y, NULL)",
                 "spark2": "IF(y <> 0, x / y, NULL)",
-                "spark": "IF(y <> 0, x / y, NULL)",
-                "databricks": "IF(y <> 0, x / y, NULL)",
+                "spark": "TRY_DIVIDE(x, y)",
+                "databricks": "TRY_DIVIDE(x, y)",
                 "snowflake": "IFF(y <> 0, x / y, NULL)",
                 "postgres": "CASE WHEN y <> 0 THEN CAST(x AS DOUBLE PRECISION) / y ELSE NULL END",
             },
@@ -1783,8 +1783,8 @@ def test_bigquery(self):
                 "trino": "IF((2 * y) <> 0, CAST((x + 1) AS DOUBLE) / (2 * y), NULL)",
                 "hive": "IF((2 * y) <> 0, (x + 1) / (2 * y), NULL)",
                 "spark2": "IF((2 * y) <> 0, (x + 1) / (2 * y), NULL)",
-                "spark": "IF((2 * y) <> 0, (x + 1) / (2 * y), NULL)",
-                "databricks": "IF((2 * y) <> 0, (x + 1) / (2 * y), NULL)",
+                "spark": "TRY_DIVIDE(x + 1, 2 * y)",
+                "databricks": "TRY_DIVIDE(x + 1, 2 * y)",
                 "snowflake": "IFF((2 * y) <> 0, (x + 1) / (2 * y), NULL)",
                 "postgres": "CASE WHEN (2 * y) <> 0 THEN CAST((x + 1) AS DOUBLE PRECISION) / (2 * y) ELSE NULL END",
             },

tests/dialects/test_bigquery.py

@@ -510,6 +510,18 @@ def test_iff(self):
             },
         )
 
+    def test_try_divide(self):
+        self.validate_all(
+            "SELECT TRY_DIVIDE(a, b)",
+            read={"databricks": "SELECT TRY_DIVIDE(a, b)"},
+            write={
+                "databricks": "SELECT TRY_DIVIDE(a, b)",
+                "snowflake": "SELECT IFF(b <> 0, a / b, NULL)",
+                "duckdb": "SELECT CASE WHEN b <> 0 THEN a / b ELSE NULL END",
+                "spark": "SELECT TRY_DIVIDE(a, b)",
+            },
+        )
+
     def test_declare(self):
         self.validate_identity("DECLARE VAR x INT", "DECLARE x INT")
         self.validate_identity("DECLARE x INT")

tests/dialects/test_databricks.py

@@ -1382,3 +1382,18 @@ def test_set_variable(self):
                 "databricks": "SET VARIABLE (v1, v2) = (SELECT 1, 2)",
             },
         )
+
+    def test_try_divide(self):
+        self.validate_all(
+            "SELECT TRY_DIVIDE(a, b)",
+            read={
+                "spark": "SELECT TRY_DIVIDE(a, b)",
+                "databricks": "SELECT TRY_DIVIDE(a, b)",
+            },
+            write={
+                "spark": "SELECT TRY_DIVIDE(a, b)",
+                "databricks": "SELECT TRY_DIVIDE(a, b)",
+                "snowflake": "SELECT IFF(b <> 0, a / b, NULL)",
+                "duckdb": "SELECT CASE WHEN b <> 0 THEN a / b ELSE NULL END",
+            },
+        )