feat(duckdb): Handle WEEK, WEEK(day), ISOWEEK transpilation for DATE_DIFF function

Author: fivetran-amrutabhimsenayachit

sqlglot/dialects/bigquery.py

@@ -152,6 +152,32 @@ def _pushdown_cte_column_names(expression: exp.Expression) -> exp.Expression:
     return expression
 
 
+def _normalize_week_units(expression: exp.Expression) -> exp.Expression:
+    """
+    Normalize WEEK and ISOWEEK units in DATE_DIFF to WeekStart expressions.
+
+    Transformations:
+    - WEEK -> WeekStart(this=Var('SUNDAY'))
+    - ISOWEEK -> WeekStart(this=Var('MONDAY'))
+
+    Note: WEEK(day) is already parsed as WeekStart by the parser.
+    """
+    if isinstance(expression, exp.DateDiff):
+        unit = expression.args.get("unit")
+
+        if isinstance(unit, exp.Var):
+            unit_name = unit.this.upper() if isinstance(unit.this, str) else str(unit.this)
+
+            if unit_name == "WEEK":
+                # BigQuery's WEEK uses Sunday as the start of the week
+                expression.set("unit", exp.WeekStart(this=exp.var("SUNDAY")))
+            elif unit_name == "ISOWEEK":
+                # ISOWEEK uses Monday as the start of the week
+                expression.set("unit", exp.WeekStart(this=exp.var("MONDAY")))
+
+    return expression
+
+
 def _build_parse_timestamp(args: t.List) -> exp.StrToTime:
     this = build_formatted_time(exp.StrToTime, "bigquery")([seq_get(args, 1), seq_get(args, 0)])
     this.set("zone", seq_get(args, 2))
@@ -409,6 +435,17 @@ class BigQuery(Dialect):
 
     EXPRESSION_METADATA = EXPRESSION_METADATA.copy()
 
+    def parse(self, sql: str, **opts) -> t.List[t.Optional[exp.Expression]]:
+        """Parse SQL and normalize BigQuery-specific constructs to canonical form."""
+        expressions = super().parse(sql, **opts)
+
+        # Normalize WEEK units in DATE_DIFF to canonical WeekStart expressions
+        for expression in expressions:
+            if expression:
+                expression.transform(_normalize_week_units, copy=False)
+
+        return expressions
+
     def normalize_identifier(self, expression: E) -> E:
         if (
             isinstance(expression, exp.Identifier)
@@ -1064,7 +1101,7 @@ class Generator(generator.Generator):
             exp.CTE: transforms.preprocess([_pushdown_cte_column_names]),
             exp.DateAdd: date_add_interval_sql("DATE", "ADD"),
             exp.DateDiff: lambda self, e: self.func(
-                "DATE_DIFF", e.this, e.expression, unit_to_var(e)
+                "DATE_DIFF", e.this, e.expression, self._date_diff_unit_sql(e)
             ),
             exp.DateFromParts: rename_func("DATE"),
             exp.DateStrToDate: datestrtodate_sql,
@@ -1317,6 +1354,40 @@ class Generator(generator.Generator):
             "within",
         }
 
+        def _date_diff_unit_sql(self, expression: exp.DateDiff) -> str:
+            """
+            Convert canonical WeekStart expression back to BigQuery syntax.
+
+            Canonical form -> BigQuery syntax:
+            - WeekStart(SUNDAY) -> WEEK (BigQuery's default)
+            - WeekStart(MONDAY) -> ISOWEEK
+            - WeekStart(other day) -> WEEK(day)
+            - Other units -> use unit_to_var as normal
+            """
+            unit = expression.args.get("unit")
+
+            if isinstance(unit, exp.WeekStart):
+                # Extract the day from WeekStart
+                day_var = unit.this
+                if isinstance(day_var, exp.Var):
+                    day_name = (
+                        day_var.this.upper() if isinstance(day_var.this, str) else str(day_var.this)
+                    )
+
+                    if day_name == "SUNDAY":
+                        # BigQuery's default WEEK is Sunday-start
+                        return self.sql(exp.var("WEEK"))
+                    elif day_name == "MONDAY":
+                        # Use ISOWEEK for Monday-start
+                        return self.sql(exp.var("ISOWEEK"))
+                    else:
+                        # For other days, use WEEK(day) syntax
+                        return self.sql(exp.Week(this=day_var))
+
+            # For other units, use default behavior
+            unit_expr = unit_to_var(expression)
+            return self.sql(unit_expr) if unit_expr else "DAY"
+
         def datetrunc_sql(self, expression: exp.DateTrunc) -> str:
             unit = expression.unit
             unit_sql = unit.name if unit.is_string else self.sql(unit)

sqlglot/dialects/duckdb.py

@@ -68,6 +68,17 @@
     "\u001f": 31,
 }
 
+# DuckDB's EXTRACT(DAYOFWEEK) returns: 0=Sunday, 1=Monday, ..., 6=Saturday
+_WEEK_START_DAY_TO_DOW = {
+    "MONDAY": 1,
+    "TUESDAY": 2,
+    "WEDNESDAY": 3,
+    "THURSDAY": 4,
+    "FRIDAY": 5,
+    "SATURDAY": 6,
+    "SUNDAY": 0,
+}
+
 
 # BigQuery -> DuckDB conversion for the DATE function
 def _date_sql(self: DuckDB.Generator, expression: exp.Date) -> str:
@@ -249,9 +260,68 @@ def _implicit_datetime_cast(
     return arg
 
 
+def _extract_week_start_day(unit: t.Optional[exp.Expression]) -> t.Optional[t.Tuple[str, int]]:
+    """
+    Extract week start day name and DOW number from a Week or WeekStart expression.
+    """
+    if not isinstance(unit, (exp.Week, exp.WeekStart)):
+        return None
+
+    day_var = unit.this
+    if not isinstance(day_var, exp.Var):
+        return None
+
+    start_day = day_var.this.upper() if isinstance(day_var.this, str) else str(day_var.this)
+    start_dow = _WEEK_START_DAY_TO_DOW.get(start_day)
+
+    if start_dow is None:
+        return None
+
+    return (start_day, start_dow)
+
+
+def _build_week_trunc_expression(date_expr: exp.Expression, start_dow: int) -> exp.Expression:
+    """
+    Build DATE_TRUNC expression for week boundaries with custom start day.
+    Formula: shift = 1 - start_dow, then DATE_TRUNC('week', date + INTERVAL shift DAY)
+    """
+    if start_dow == 1:
+        # No shift needed for Monday-based weeks (ISO standard)
+        return exp.Anonymous(this="DATE_TRUNC", expressions=[exp.Literal.string("week"), date_expr])
+
+    # Shift date to align week boundaries with ISO Monday
+    shift_days = 1 - start_dow
+    shifted_date = exp.DateAdd(
+        this=date_expr,
+        expression=exp.Interval(this=exp.Literal.string(str(shift_days)), unit=exp.var("DAY")),
+    )
+
+    return exp.Anonymous(this="DATE_TRUNC", expressions=[exp.Literal.string("week"), shifted_date])
+
+
 def _date_diff_sql(self: DuckDB.Generator, expression: exp.DateDiff) -> str:
+    """
+    Generate DATE_DIFF SQL for DuckDB using DATE_TRUNC-based week alignment.
+    """
     this = _implicit_datetime_cast(expression.this)
     expr = _implicit_datetime_cast(expression.expression)
+    unit = expression.args.get("unit")
+
+    week_start = _extract_week_start_day(unit)
+    if week_start and this and expr:
+        _, start_dow = week_start
+
+        # Build truncated week boundary expressions
+        truncated_this = _build_week_trunc_expression(this, start_dow)
+        truncated_expr = _build_week_trunc_expression(expr, start_dow)
+
+        # Calculate week difference
+        day_diff = exp.DateDiff(
+            this=truncated_this, expression=truncated_expr, unit=exp.Literal.string("day")
+        )
+        result = exp.IntDiv(this=day_diff, expression=exp.Literal.number(7))
+
+        return self.sql(result)
 
     return self.func("DATE_DIFF", unit_to_str(expression), expr, this)
 

tests/dialects/test_bigquery.py

@@ -3216,6 +3216,56 @@ def test_week(self):
             "EXTRACT(WEEK(THURSDAY) FROM CAST('2013-12-25' AS DATE))",
         )
 
+        # BigQuery → DuckDB transpilation tests for DATE_DIFF with week units
+        # Test WEEK(MONDAY) - Monday-based week (normalized to ISOWEEK)
+        self.validate_all(
+            "DATE_DIFF('2024-01-15', '2024-01-08', WEEK(MONDAY))",
+            write={
+                "bigquery": "DATE_DIFF('2024-01-15', '2024-01-08', ISOWEEK)",
+                "duckdb": "DATE_DIFF('DAY', DATE_TRUNC('week', CAST('2024-01-08' AS DATE)), DATE_TRUNC('week', CAST('2024-01-15' AS DATE))) // 7",
+            },
+        )
+        # Test WEEK(SUNDAY) - Sunday-based week (normalized to WEEK)
+        self.validate_all(
+            "DATE_DIFF('2024-01-15', '2024-01-08', WEEK(SUNDAY))",
+            write={
+                "bigquery": "DATE_DIFF('2024-01-15', '2024-01-08', WEEK)",
+                "duckdb": "DATE_DIFF('DAY', DATE_TRUNC('week', CAST('2024-01-08' AS DATE) + INTERVAL '1' DAY), DATE_TRUNC('week', CAST('2024-01-15' AS DATE) + INTERVAL '1' DAY)) // 7",
+            },
+        )
+        # Test WEEK(SATURDAY) - Saturday-based week calculation
+        self.validate_all(
+            "DATE_DIFF('2024-01-15', '2024-01-08', WEEK(SATURDAY))",
+            write={
+                "bigquery": "DATE_DIFF('2024-01-15', '2024-01-08', WEEK(SATURDAY))",
+                "duckdb": "DATE_DIFF('DAY', DATE_TRUNC('week', CAST('2024-01-08' AS DATE) + INTERVAL '-5' DAY), DATE_TRUNC('week', CAST('2024-01-15' AS DATE) + INTERVAL '-5' DAY)) // 7",
+            },
+        )
+        # Test WEEK - Default Sunday-based week calculation
+        self.validate_all(
+            "DATE_DIFF('2024-01-15', '2024-01-08', WEEK)",
+            write={
+                "bigquery": "DATE_DIFF('2024-01-15', '2024-01-08', WEEK)",
+                "duckdb": "DATE_DIFF('DAY', DATE_TRUNC('week', CAST('2024-01-08' AS DATE) + INTERVAL '1' DAY), DATE_TRUNC('week', CAST('2024-01-15' AS DATE) + INTERVAL '1' DAY)) // 7",
+            },
+        )
+        # Test ISOWEEK - ISO 8601 Monday-based week calculation
+        self.validate_all(
+            "DATE_DIFF('2024-01-15', '2024-01-08', ISOWEEK)",
+            write={
+                "bigquery": "DATE_DIFF('2024-01-15', '2024-01-08', ISOWEEK)",
+                "duckdb": "DATE_DIFF('DAY', DATE_TRUNC('week', CAST('2024-01-08' AS DATE)), DATE_TRUNC('week', CAST('2024-01-15' AS DATE))) // 7",
+            },
+        )
+        # Test with DATE literal - Explicit DATE casting
+        self.validate_all(
+            "DATE_DIFF(DATE '2024-01-15', DATE '2024-01-08', WEEK(MONDAY))",
+            write={
+                "bigquery": "DATE_DIFF(CAST('2024-01-15' AS DATE), CAST('2024-01-08' AS DATE), ISOWEEK)",
+                "duckdb": "DATE_DIFF('DAY', DATE_TRUNC('week', CAST('2024-01-08' AS DATE)), DATE_TRUNC('week', CAST('2024-01-15' AS DATE))) // 7",
+            },
+        )
+
     def test_approx_qunatiles(self):
         self.validate_identity("APPROX_QUANTILES(foo, 2)")
         self.validate_identity("APPROX_QUANTILES(DISTINCT foo, 2 RESPECT NULLS)")

tests/dialects/test_duckdb.py

@@ -1962,6 +1962,24 @@ def test_extract_date_parts(self):
                 # All of these should remain as is, they don't have synonyms
                 self.validate_identity(f"EXTRACT({part} FROM foo)")
 
+    def test_date_diff_week(self):
+        # Test Monday-based week (ISO week) - no offset needed
+        self.validate_identity(
+            "DATE_DIFF('DAY', DATE_TRUNC('WEEK', CAST('2024-01-08' AS DATE)), DATE_TRUNC('WEEK', CAST('2024-01-15' AS DATE))) // 7"
+        )
+        # Test Sunday-based week - shift by +1 day to align with ISO Monday
+        self.validate_identity(
+            "DATE_DIFF('DAY', DATE_TRUNC('WEEK', CAST('2024-01-08' AS DATE) + INTERVAL '1' DAY), DATE_TRUNC('WEEK', CAST('2024-01-15' AS DATE) + INTERVAL '1' DAY)) // 7"
+        )
+        # Test Saturday-based week - shift by -5 days to align with ISO Monday
+        self.validate_identity(
+            "DATE_DIFF('DAY', DATE_TRUNC('WEEK', CAST('2024-01-08' AS DATE) + INTERVAL '-5' DAY), DATE_TRUNC('WEEK', CAST('2024-01-15' AS DATE) + INTERVAL '-5' DAY)) // 7"
+        )
+        # Test zero weeks between dates in same week
+        self.validate_identity(
+            "DATE_DIFF('DAY', DATE_TRUNC('WEEK', CAST('2024-01-01' AS DATE)), DATE_TRUNC('WEEK', CAST('2024-01-01' AS DATE))) // 7"
+        )
+
     def test_set_item(self):
         self.validate_identity("SET memory_limit = '10GB'")
         self.validate_identity("SET SESSION default_collation = 'nocase'")