handle date_trunc(time_part, time) and clean up

Author: toriwei

sqlglot/dialects/duckdb.py

@@ -2456,7 +2456,12 @@ def datetrunc_sql(self, expression: exp.DateTrunc) -> str:
             date = expression.this
             result = self.func("DATE_TRUNC", unit, date)
 
-            if expression.args.get("cast_to_granularity_type") and date.type:
+            if not date.type:
+                from sqlglot.optimizer.annotate_types import annotate_types
+
+                date = annotate_types(date, dialect=self.dialect)
+
+            if date.type and expression.args.get("cast_to_granularity_type"):
                 return self.sql(exp.Cast(this=result, to=date.type))
             return result
 
@@ -2475,7 +2480,23 @@ def timestamptrunc_sql(self, expression: exp.TimestampTrunc) -> str:
                 return self.sql(exp.AtTimeZone(this=result_sql, zone=zone))
 
             result = self.func("DATE_TRUNC", unit, timestamp)
-            if expression.args.get("cast_to_granularity_type") and timestamp.type:
+            if not timestamp.type:
+                from sqlglot.optimizer.annotate_types import annotate_types
+
+                timestamp = annotate_types(timestamp, dialect=self.dialect)
+
+            if timestamp.type and timestamp.is_type(
+                exp.DataType.Type.TIME, exp.DataType.Type.TIMETZ
+            ):
+                dummy_date = exp.Cast(
+                    this=exp.Literal.string("1970-01-01"),
+                    to=exp.DataType(this=exp.DataType.Type.DATE),
+                )
+                date_time = exp.Add(this=dummy_date, expression=timestamp)
+                result = self.func("DATE_TRUNC", unit, date_time)
+                return self.sql(exp.Cast(this=result, to=timestamp.type))
+
+            if timestamp.type and expression.args.get("cast_to_granularity_type"):
                 return self.sql(exp.Cast(this=result, to=timestamp.type))
             return result
 

tests/dialects/test_snowflake.py

@@ -2676,56 +2676,47 @@ def test_timestamps(self):
             },
         )
         self.validate_all(
-            "DATE_TRUNC('YEAR', CAST('2026-01-01 00:00:00' AS TIMESTAMP))",
+            "DATE_TRUNC('HOUR', CAST('2026-01-01 00:00:00' AS TIMESTAMP))",
             write={
-                "snowflake": "DATE_TRUNC('YEAR', CAST('2026-01-01 00:00:00' AS TIMESTAMP))",
-                "duckdb": "DATE_TRUNC('YEAR', CAST('2026-01-01 00:00:00' AS TIMESTAMP))",
+                "snowflake": "DATE_TRUNC('HOUR', CAST('2026-01-01 00:00:00' AS TIMESTAMP))",
+                "duckdb": "DATE_TRUNC('HOUR', CAST('2026-01-01 00:00:00' AS TIMESTAMP))",
             },
         )
+        # Snowflake's DATE_TRUNC return type matches type of the expresison
+        # DuckDB's DATE_TRUNC return type matches type of granularity part.
+        # In Snowflake --> DuckDB, DATE_TRUNC(date_part, timestamp) should be cast to timestamp to preserve Snowflake behavior.
         self.validate_all(
-            "DATE_TRUNC('HOUR', CAST('2026-01-01' AS DATE))",
+            "DATE_TRUNC(YEAR, TIMESTAMP '2026-01-01 00:00:00')",
             write={
-                "snowflake": "DATE_TRUNC('HOUR', CAST('2026-01-01' AS DATE))",
-                "duckdb": "DATE_TRUNC('HOUR', CAST('2026-01-01' AS DATE))",
+                "snowflake": "DATE_TRUNC('YEAR', CAST('2026-01-01 00:00:00' AS TIMESTAMP))",
+                "duckdb": "CAST(DATE_TRUNC('YEAR', CAST('2026-01-01 00:00:00' AS TIMESTAMP)) AS TIMESTAMP)",
             },
         )
         self.validate_all(
-            "DATE_TRUNC('HOUR', CAST('2026-01-01 00:00:00' AS TIMESTAMP))",
+            "DATE_TRUNC(MONTH, CAST('2024-06-15 14:23:45' AS TIMESTAMPTZ))",
             write={
-                "snowflake": "DATE_TRUNC('HOUR', CAST('2026-01-01 00:00:00' AS TIMESTAMP))",
-                "duckdb": "DATE_TRUNC('HOUR', CAST('2026-01-01 00:00:00' AS TIMESTAMP))",
+                "snowflake": "DATE_TRUNC('MONTH', CAST('2024-06-15 14:23:45' AS TIMESTAMPTZ))",
+                "duckdb": "CAST(DATE_TRUNC('MONTH', CAST('2024-06-15 14:23:45' AS TIMESTAMPTZ)) AS TIMESTAMPTZ)",
             },
         )
-        # Snowflake's DATE_TRUNC return type matches type of the expresison
-        # DuckDB's DATE_TRUNC return type matches type of granularity part.
-        # In Snowflake --> DuckDB, DATE_TRUNC(date_part, timestamp) should be cast to timestamp to preserve Snowflake behavior.
-        expr = self.parse_one("DATE_TRUNC(YEAR, TIMESTAMP '2026-01-01 00:00:00')")
-        annotated = annotate_types(expr, dialect="snowflake")
-        self.assertEqual(
-            annotated.sql("duckdb"),
-            "CAST(DATE_TRUNC('YEAR', CAST('2026-01-01 00:00:00' AS TIMESTAMP)) AS TIMESTAMP)",
-        )
 
-        expr = self.parse_one("DATE_TRUNC(MONTH, CAST('2024-06-15 14:23:45' AS TIMESTAMPTZ))")
-        annotated = annotate_types(expr, dialect="snowflake")
-        self.assertEqual(
-            annotated.sql("duckdb"),
-            "CAST(DATE_TRUNC('MONTH', CAST('2024-06-15 14:23:45' AS TIMESTAMPTZ)) AS TIMESTAMPTZ)",
-        )
-        # Time unit and timestamp should not trigger extra type casting
-        expr = self.parse_one("DATE_TRUNC(HOUR, TIMESTAMP '2024-06-15 14:23:45')")
-        annotated = annotate_types(expr, dialect="snowflake")
-        self.assertEqual(
-            annotated.sql("duckdb"),
-            "DATE_TRUNC('HOUR', CAST('2024-06-15 14:23:45' AS TIMESTAMP))",
+        # In Snowflake --> DuckDB, DATE_TRUNC(time_part, date) should be cast to date to preserve Snowflake behavior.
+        self.validate_all(
+            "DATE_TRUNC('HOUR', CAST('2026-01-01' AS DATE))",
+            write={
+                "snowflake": "DATE_TRUNC('HOUR', CAST('2026-01-01' AS DATE))",
+                "duckdb": "CAST(DATE_TRUNC('HOUR', CAST('2026-01-01' AS DATE)) AS DATE)",
+            },
         )
 
-        # In Snowflake --> DuckDB, DATE_TRUNC(time_part, date) should be cast to date to preserve Snowflake behavior.
-        expr = self.parse_one("DATE_TRUNC('HOUR', DATE '2026-01-01')")
-        annotated = annotate_types(expr, dialect="snowflake")
-        self.assertEqual(
-            annotated.sql("duckdb"),
-            "CAST(DATE_TRUNC('HOUR', CAST('2026-01-01' AS DATE)) AS DATE)",
+        # DuckDB does not support DATE_TRUNC(time_part, time), so we add a dummy date to generate DATE_TRUNC(time_part, date) --> DATE in DuckDB
+        # Then it is casted to a time (HH:MM:SS) to match Snowflake.
+        self.validate_all(
+            "DATE_TRUNC('HOUR', CAST('14:23:45.123456' AS TIME))",
+            write={
+                "snowflake": "DATE_TRUNC('HOUR', CAST('14:23:45.123456' AS TIME))",
+                "duckdb": "CAST(DATE_TRUNC('HOUR', CAST('1970-01-01' AS DATE) + CAST('14:23:45.123456' AS TIME)) AS TIME)",
+            },
         )
         self.validate_identity("TO_DATE('12345')").assert_is(exp.Anonymous)