fix(duckdb): Added generic implementation

Author: fivetran-amrutabhimsenayachit

sqlglot/dialects/bigquery.py

@@ -152,32 +152,6 @@ 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))
@@ -234,6 +208,34 @@ def _ts_or_ds_diff_sql(self: BigQuery.Generator, expression: exp.TsOrDsDiff) ->
     return self.func("DATE_DIFF", expression.this, expression.expression, unit)
 
 
+def _serialize_bq_datetime_diff_unit(self: BigQuery.Generator, expression: exp.Expression) -> str:
+    """
+    Serialize unit for *_DIFF functions, converting Week expressions to BigQuery syntax.
+
+    Canonical form -> BigQuery syntax:
+    - Week(SUNDAY) -> WEEK (BigQuery's default)
+    - Week(MONDAY) -> ISOWEEK
+    - Week(other day) -> WEEK(day)
+    - Other units -> use unit_to_var
+
+    """
+    from sqlglot.dialects.dialect import extract_week_unit_info
+
+    unit = expression.args.get("unit")
+    day_name = extract_week_unit_info(unit, include_dow=False)
+
+    if day_name and isinstance(day_name, str):
+        if day_name == "SUNDAY":
+            return self.sql(exp.var("WEEK"))
+        elif day_name == "MONDAY":
+            return self.sql(exp.var("ISOWEEK"))
+        else:
+            return self.sql(exp.Week(this=exp.var(day_name)))
+
+    unit_expr = unit_to_var(expression)
+    return self.sql(unit_expr) if unit_expr else "DAY"
+
+
 def _unix_to_time_sql(self: BigQuery.Generator, expression: exp.UnixToTime) -> str:
     scale = expression.args.get("scale")
     timestamp = expression.this
@@ -267,6 +269,46 @@ def _build_datetime(args: t.List) -> exp.Func:
     return exp.TimestampFromParts.from_arg_list(args)
 
 
+def _normalize_week_unit(unit: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
+    """
+    In BigQuery, plain WEEK defaults to Sunday-start weeks.
+     Normalize plain WEEK to WEEK(SUNDAY) to preserve the semantic in the AST for correct cross-dialect transpilation.
+    """
+    unit_name = None
+
+    if isinstance(unit, exp.Var):
+        unit_name = str(unit.this)
+    elif isinstance(unit, exp.Column) and isinstance(unit.this, exp.Identifier):
+        unit_name = str(unit.this.this)
+
+    if unit_name and unit_name.upper() == "WEEK":
+        return exp.Week(this=exp.var("SUNDAY"))
+
+    return unit
+
+
+def build_date_time_diff_with_week_normalization(
+    exp_class: t.Type[E],
+) -> t.Callable[[t.List], E]:
+    """
+    Factory for *_DIFF functions that normalizes plain WEEK units to WEEK(SUNDAY).
+
+    These functions have signature: FUNC(expr1, expr2, date_part)
+    where date_part is at argument index 2.
+
+    Supports: DATE_DIFF, DATETIME_DIFF, TIME_DIFF, TIMESTAMP_DIFF
+    """
+
+    def _builder(args: t.List) -> E:
+        return exp_class(
+            this=seq_get(args, 0),
+            expression=seq_get(args, 1),
+            unit=_normalize_week_unit(seq_get(args, 2)),
+        )
+
+    return _builder
+
+
 def _build_regexp_extract(
     expr_type: t.Type[E], default_group: t.Optional[exp.Expression] = None
 ) -> t.Callable[[t.List], E]:
@@ -435,17 +477,6 @@ 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)
@@ -569,6 +600,7 @@ class Parser(parser.Parser):
             "CONTAINS_SUBSTR": _build_contains_substring,
             "DATE": _build_date,
             "DATE_ADD": build_date_delta_with_interval(exp.DateAdd),
+            "DATE_DIFF": build_date_time_diff_with_week_normalization(exp.DateDiff),
             "DATE_SUB": build_date_delta_with_interval(exp.DateSub),
             "DATE_TRUNC": lambda args: exp.DateTrunc(
                 unit=seq_get(args, 1),
@@ -1101,7 +1133,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, self._date_diff_unit_sql(e)
+                "DATE_DIFF", e.this, e.expression, _serialize_bq_datetime_diff_unit(self, e)
             ),
             exp.DateFromParts: rename_func("DATE"),
             exp.DateStrToDate: datestrtodate_sql,
@@ -1354,40 +1386,6 @@ 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/dialect.py

@@ -687,6 +687,23 @@ class Dialect(metaclass=_Dialect):
         "CENTURIES": "CENTURY",
     }
 
+    WEEK_UNIT_SEMANTICS = {
+        "WEEK": ("SUNDAY", 0),
+        "ISOWEEK": ("MONDAY", 1),
+        "WEEKISO": ("MONDAY", 1),
+    }
+
+    # Days of week to DOW numbers (ISO standard: Monday=1, Sunday=0)
+    WEEK_START_DAY_TO_DOW = {
+        "MONDAY": 1,
+        "TUESDAY": 2,
+        "WEDNESDAY": 3,
+        "THURSDAY": 4,
+        "FRIDAY": 5,
+        "SATURDAY": 6,
+        "SUNDAY": 0,
+    }
+
     # Specifies what types a given type can be coerced into
     COERCES_TO: t.Dict[exp.DataType.Type, t.Set[exp.DataType.Type]] = {}
 
@@ -1558,6 +1575,52 @@ def map_date_part(part, dialect: DialectType = Dialect):
     return part
 
 
+def extract_week_unit_info(
+    unit: t.Optional[exp.Expression], include_dow: bool = False
+) -> t.Optional[t.Union[str, t.Tuple[str, int]]]:
+    """
+    Extract week unit information from AST node.
+
+    This helper provides a unified way to handle week units across dialects.
+
+    Args:
+        unit: The unit expression (Var, Week, or WeekStart)
+        include_dow: If True, return (day_name, dow_number) tuple for transformations
+                    If False, return just day_name string for serialization
+
+    Returns:
+        - If include_dow=False: day_name (e.g., "SUNDAY")
+        - If include_dow=True: (day_name, dow_number) (e.g., ("SUNDAY", 0))
+        - None if not a week unit
+
+    """
+    # Handle plain Var expressions for ISOWEEK/WEEKISO only
+    # NOTE: Plain Var('WEEK') is NOT handled to avoid breaking other dialects
+    if isinstance(unit, exp.Var):
+        unit_name = unit.this.upper() if isinstance(unit.this, str) else str(unit.this)
+        # Only handle ISOWEEK/WEEKISO variants, not plain WEEK
+        if unit_name in ("ISOWEEK", "WEEKISO"):
+            week_info = Dialect.WEEK_UNIT_SEMANTICS.get(unit_name)
+            if week_info:
+                day_name, dow = week_info
+                return (day_name, dow) if include_dow else day_name
+        return None
+
+    # Handle Week/WeekStart expressions with explicit day
+    if isinstance(unit, (exp.Week, exp.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 include_dow:
+                dow_value = Dialect.WEEK_START_DAY_TO_DOW.get(day_name)
+                return (day_name, dow_value) if dow_value is not None else None
+
+            return day_name
+
+    return None
+
+
 def no_last_day_sql(self: Generator, expression: exp.LastDay) -> str:
     trunc_curr_date = exp.func("date_trunc", "month", expression.this)
     plus_one_month = exp.func("date_add", trunc_curr_date, 1, "month")

sqlglot/dialects/duckdb.py

@@ -68,17 +68,6 @@
     "\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:
@@ -262,22 +251,22 @@ def _implicit_datetime_cast(
 
 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
+    Extract week start day name and DOW number from a Week, WeekStart, or plain Var expression.
 
-    day_var = unit.this
-    if not isinstance(day_var, exp.Var):
-        return None
+    Uses extract_week_unit_info(include_dow=True) for uniform week unit handling.
 
-    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
+    Handles:
+    - Var('WEEK') -> ('SUNDAY', 0)  # BigQuery default
+    - Var('ISOWEEK') -> ('MONDAY', 1)
+    - Week(Var('day')) -> ('day', dow)
+    - WeekStart(Var('day')) -> ('day', dow)
+    """
+    from sqlglot.dialects.dialect import extract_week_unit_info
 
-    return (start_day, start_dow)
+    # Use shared helper with include_dow=True to get (day_name, dow_number)
+    result = extract_week_unit_info(unit, include_dow=True)
+    # When include_dow=True, result is either None or Tuple[str, int]
+    return result if result is None or isinstance(result, tuple) else None
 
 
 def _build_week_trunc_expression(date_expr: exp.Expression, start_dow: int) -> exp.Expression: