feat(snowflake)!: support transpilation of TRY_TO_BINARY from Snowflake to DuckDB (#6629)

* support transpilation of TRY_TO_BINARY from Snowflake to DuckDB

* update tests

Author: fivetran-felixhuang

sqlglot/dialects/duckdb.py

@@ -1686,29 +1686,41 @@ def zipf_sql(self: DuckDB.Generator, expression: exp.Zipf) -> str:
 
         def tobinary_sql(self: DuckDB.Generator, expression: exp.ToBinary) -> str:
             """
-            TO_BINARY(value, format) transpilation if the return type is BINARY:
+            TO_BINARY and TRY_TO_BINARY transpilation:
             - 'HEX': TO_BINARY('48454C50', 'HEX') → UNHEX('48454C50')
             - 'UTF-8': TO_BINARY('TEST', 'UTF-8') → ENCODE('TEST')
             - 'BASE64': TO_BINARY('SEVMUA==', 'BASE64') → FROM_BASE64('SEVMUA==')
 
-            format can be 'HEX', 'UTF-8' or 'BASE64'
-            return type can be either VARCHAR or BINARY
+            For TRY_TO_BINARY (safe=True), wrap with TRY():
+            - 'HEX': TRY_TO_BINARY('invalid', 'HEX') → TRY(UNHEX('invalid'))
             """
             value = expression.this
             format_arg = expression.args.get("format")
+            is_safe = expression.args.get("safe")
 
             fmt = "HEX"
             if format_arg:
                 fmt = format_arg.name.upper()
 
             if expression.is_type(exp.DataType.Type.BINARY):
                 if fmt == "UTF-8":
-                    return self.func("ENCODE", value)
-                if fmt == "BASE64":
-                    return self.func("FROM_BASE64", value)
+                    result = self.func("ENCODE", value)
+                elif fmt == "BASE64":
+                    result = self.func("FROM_BASE64", value)
+                elif fmt == "HEX":
+                    result = self.func("UNHEX", value)
+                else:
+                    if is_safe:
+                        return self.sql(exp.null())
+                    else:
+                        self.unsupported(f"format {fmt} is not supported")
+                        result = self.func("TO_BINARY", value)
+
+                # Wrap with TRY() for TRY_TO_BINARY
+                if is_safe:
+                    result = self.func("TRY", result)
 
-                # Hex
-                return self.func("UNHEX", value)
+                return result
 
             # Fallback, which needs to be updated if want to support transpilation from other dialects than Snowflake
             return self.func("TO_BINARY", value)

tests/dialects/test_duckdb.py

@@ -724,23 +724,6 @@ def test_duckdb(self):
                 "duckdb": "CREATE TABLE IF NOT EXISTS t (cola INT, colb TEXT)",
             },
         )
-
-        expr = self.parse_one("TO_BINARY('48454C50', 'HEX')", dialect="snowflake")
-        annotated = annotate_types(expr, dialect="snowflake")
-        self.assertEqual(annotated.sql("duckdb"), "UNHEX('48454C50')")
-
-        expr = self.parse_one("TO_BINARY('48454C50')", dialect="snowflake")
-        annotated = annotate_types(expr, dialect="snowflake")
-        self.assertEqual(annotated.sql("duckdb"), "UNHEX('48454C50')")
-
-        expr = self.parse_one("TO_BINARY('TEST', 'UTF-8')", dialect="snowflake")
-        annotated = annotate_types(expr, dialect="snowflake")
-        self.assertEqual(annotated.sql("duckdb"), "ENCODE('TEST')")
-
-        expr = self.parse_one("TO_BINARY('SEVMUA==', 'BASE64')", dialect="snowflake")
-        annotated = annotate_types(expr, dialect="snowflake")
-        self.assertEqual(annotated.sql("duckdb"), "FROM_BASE64('SEVMUA==')")
-
         self.validate_all(
             "[0, 1, 2]",
             read={

tests/dialects/test_snowflake.py

@@ -353,8 +353,6 @@ def test_snowflake(self):
         self.validate_identity("TO_DECFLOAT('1,234.56', '999,999.99')")
         self.validate_identity("TRY_TO_DECFLOAT('123.456')")
         self.validate_identity("TRY_TO_DECFLOAT('1,234.56', '999,999.99')")
-        self.validate_identity("TRY_TO_BINARY('48656C6C6F')")
-        self.validate_identity("TRY_TO_BINARY('48656C6C6F', 'HEX')")
         self.validate_all(
             "TRY_TO_BOOLEAN('true')",
             write={
@@ -507,9 +505,6 @@ def test_snowflake(self):
         self.validate_identity("SELECT a, exclude, b FROM xxx")
         self.validate_identity("SELECT ARRAY_SORT(x, TRUE, FALSE)")
         self.validate_identity("SELECT BOOLXOR_AGG(col) FROM tbl")
-        self.validate_identity("SELECT TO_BINARY('C2')")
-        self.validate_identity("SELECT TO_BINARY('C2', 'HEX')")
-        self.validate_identity("SELECT TO_BINARY('café', 'UTF-8')")
         self.validate_identity(
             "SELECT PERCENTILE_DISC(0.9) WITHIN GROUP (ORDER BY col) OVER (PARTITION BY category)"
         )
@@ -4326,6 +4321,43 @@ def test_round(self):
             },
         )
 
+    def test_to_binary(self):
+        expr = self.validate_identity("TO_BINARY('48454C50', 'HEX')")
+        annotated = annotate_types(expr, dialect="snowflake")
+        self.assertEqual(annotated.sql("duckdb"), "UNHEX('48454C50')")
+
+        expr = self.validate_identity("TO_BINARY('48454C50')")
+        annotated = annotate_types(expr, dialect="snowflake")
+        self.assertEqual(annotated.sql("duckdb"), "UNHEX('48454C50')")
+
+        expr = self.validate_identity("TO_BINARY('TEST', 'UTF-8')")
+        annotated = annotate_types(expr, dialect="snowflake")
+        self.assertEqual(annotated.sql("duckdb"), "ENCODE('TEST')")
+
+        expr = self.validate_identity("TO_BINARY('SEVMUA==', 'BASE64')")
+        annotated = annotate_types(expr, dialect="snowflake")
+        self.assertEqual(annotated.sql("duckdb"), "FROM_BASE64('SEVMUA==')")
+
+        expr = self.validate_identity("TRY_TO_BINARY('48454C50', 'HEX')")
+        annotated = annotate_types(expr, dialect="snowflake")
+        self.assertEqual(annotated.sql("duckdb"), "TRY(UNHEX('48454C50'))")
+
+        expr = self.validate_identity("TRY_TO_BINARY('48454C50')")
+        annotated = annotate_types(expr, dialect="snowflake")
+        self.assertEqual(annotated.sql("duckdb"), "TRY(UNHEX('48454C50'))")
+
+        expr = self.validate_identity("TRY_TO_BINARY('Hello', 'UTF-8')")
+        annotated = annotate_types(expr, dialect="snowflake")
+        self.assertEqual(annotated.sql("duckdb"), "TRY(ENCODE('Hello'))")
+
+        expr = self.validate_identity("TRY_TO_BINARY('SGVsbG8=', 'BASE64')")
+        annotated = annotate_types(expr, dialect="snowflake")
+        self.assertEqual(annotated.sql("duckdb"), "TRY(FROM_BASE64('SGVsbG8='))")
+
+        expr = self.validate_identity("TRY_TO_BINARY('Hello', 'UTF-16')")
+        annotated = annotate_types(expr, dialect="snowflake")
+        self.assertEqual(annotated.sql("duckdb"), "NULL")
+
     def test_transpile_bitwise_ops(self):
         # Binary bitwise operations
         expr = self.parse_one("SELECT BITOR(x'FF', x'0F')", dialect="snowflake")