support transpilation of TRY_TO_BINARY from Snowflake to DuckDB

Author: fivetran-felixhuang

sqlglot/dialects/duckdb.py

@@ -1583,29 +1583,41 @@ def randstr_sql(self: DuckDB.Generator, expression: exp.Randstr) -> 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", False)
 
             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

@@ -4253,6 +4253,39 @@ def test_round(self):
             },
         )
 
+    def test_transpile_to_binary(self):
+        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==')")
+
+        expr = self.parse_one("TRY_TO_BINARY('48454C50', 'HEX')", dialect="snowflake")
+        annotated = annotate_types(expr, dialect="snowflake")
+        self.assertEqual(annotated.sql("duckdb"), "TRY(UNHEX('48454C50'))")
+
+        expr = self.parse_one("TRY_TO_BINARY('48454C50')", dialect="snowflake")
+        annotated = annotate_types(expr, dialect="snowflake")
+        self.assertEqual(annotated.sql("duckdb"), "TRY(UNHEX('48454C50'))")
+
+        expr = self.parse_one("TRY_TO_BINARY('Hello', 'UTF-8')", dialect="snowflake")
+        annotated = annotate_types(expr, dialect="snowflake")
+        self.assertEqual(annotated.sql("duckdb"), "TRY(ENCODE('Hello'))")
+
+        expr = self.parse_one("TRY_TO_BINARY('SGVsbG8=', 'BASE64')", dialect="snowflake")
+        annotated = annotate_types(expr, dialect="snowflake")
+        self.assertEqual(annotated.sql("duckdb"), "TRY(FROM_BASE64('SGVsbG8='))")
+
     def test_transpile_bitwise_ops(self):
         # Binary bitwise operations
         expr = self.parse_one("SELECT BITOR(x'FF', x'0F')", dialect="snowflake")