sqlglotc 30.12.0__tar.gz → 30.13.0__tar.gz

{sqlglotc-30.12.0/sqlglotc.egg-info → sqlglotc-30.13.0}/PKG-INFO

@@ -1,15 +1,15 @@
 Metadata-Version: 2.4
 Name: sqlglotc
-Version: 30.12.0
+Version: 30.13.0
 Summary: mypyc-compiled extensions for sqlglot
 Author-email: Toby Mao <toby.mao@gmail.com>
 License-Expression: MIT
 Project-URL: Homepage, https://sqlglot.com/
 Project-URL: Repository, https://github.com/tobymao/sqlglot
 Requires-Python: >=3.10
-Requires-Dist: sqlglot==30.12.0
+Requires-Dist: sqlglot==30.13.0
 Provides-Extra: dev
 Requires-Dist: setuptools>=61.0; extra == "dev"
 Requires-Dist: setuptools_scm; extra == "dev"
-Requires-Dist: sqlglot-mypy>=2.1.0.post3; extra == "dev"
+Requires-Dist: sqlglot-mypy>=2.1.0.post9; extra == "dev"
 Dynamic: requires-dist

{sqlglotc-30.12.0 → sqlglotc-30.13.0}/pyproject.toml

@@ -7,7 +7,7 @@ license = "MIT"
 requires-python = ">= 3.10"
 
 [project.optional-dependencies]
-dev = ["setuptools >= 61.0", "setuptools_scm", "sqlglot-mypy >= 2.1.0.post3"]
+dev = ["setuptools >= 61.0", "setuptools_scm", "sqlglot-mypy >= 2.1.0.post9"]
 
 [project.urls]
 Homepage = "https://sqlglot.com/"
@@ -17,7 +17,7 @@ Repository = "https://github.com/tobymao/sqlglot"
 requires = [
     "setuptools >= 61.0",
     "setuptools_scm",
-    "sqlglot-mypy >= 2.1.0.post3",
+    "sqlglot-mypy >= 2.1.0.post9",
     "types-python-dateutil",
     "sqlglot",
 ]

{sqlglotc-30.12.0 → sqlglotc-30.13.0}/setup.py

@@ -90,6 +90,13 @@ def _source_paths():
 
 
 class build_ext(_build_ext):
+    def finalize_options(self):
+        super().finalize_options()
+        # Compile in parallel by default; builds driven by pip (wheel/sdist installs)
+        # have no way to pass -j. An explicit -j on the command line still wins.
+        if self.parallel is None:
+            self.parallel = os.cpu_count() or 1
+
     def copy_extensions_to_source(self):
         """For editable installs, put sqlglot.* .so files in the sqlglot source dir."""
         for ext in self.extensions:

{sqlglotc-30.12.0 → sqlglotc-30.13.0}/sqlglot/expressions/aggregate.py

@@ -102,6 +102,7 @@ class Count(Expression, AggFunc):
 
 class CountIf(Expression, AggFunc):
     _sql_names = ["COUNT_IF", "COUNTIF"]
+    arg_types = {"this": True, "zero_on_all_null": False}
 
 
 class CovarPop(Expression, AggFunc):
@@ -255,19 +256,19 @@ class RegrAvgy(Expression, AggFunc):
 
 
 class RegrCount(Expression, AggFunc):
-    arg_types = {"this": True, "expression": True}
+    arg_types = {"this": True, "expression": False}
 
 
 class RegrIntercept(Expression, AggFunc):
-    arg_types = {"this": True, "expression": True}
+    arg_types = {"this": True, "expression": False}
 
 
 class RegrR2(Expression, AggFunc):
-    arg_types = {"this": True, "expression": True}
+    arg_types = {"this": True, "expression": False}
 
 
 class RegrSlope(Expression, AggFunc):
-    arg_types = {"this": True, "expression": True}
+    arg_types = {"this": True, "expression": False}
 
 
 class RegrSxx(Expression, AggFunc):

{sqlglotc-30.12.0 → sqlglotc-30.13.0}/sqlglot/expressions/constraints.py

@@ -220,6 +220,11 @@ class PrimaryKey(Expression):
     arg_types = {"this": False, "expressions": True, "options": False, "include": False}
 
 
+# https://docs.databricks.com/aws/en/sql/language-manual/sql-ref-syntax-ddl-create-table-constraint
+class TimeseriesKey(Expression):
+    pass
+
+
 class IndexParameters(Expression):
     arg_types = {
         "using": False,

{sqlglotc-30.12.0 → sqlglotc-30.13.0}/sqlglot/expressions/ddl.py

@@ -432,7 +432,7 @@ class NextValueFor(Expression, Func):
 
 
 class Execute(Expression):
-    arg_types = {"this": True, "expressions": False}
+    arg_types = {"this": True, "expressions": False, "return_status": False}
 
     @property
     def name(self) -> str:

{sqlglotc-30.12.0 → sqlglotc-30.13.0}/sqlglot/expressions/math.py

@@ -168,6 +168,10 @@ class Pi(Expression, Func):
     arg_types = {}
 
 
+class Rint(Expression, Func):
+    pass
+
+
 class Round(Expression, Func):
     arg_types = {
         "this": True,

{sqlglotc-30.12.0 → sqlglotc-30.13.0}/sqlglot/expressions/string.py

@@ -477,6 +477,17 @@ class RegexpSplit(Expression, Func):
     arg_types = {"this": True, "expression": True, "limit": False}
 
 
+class RegexpSubstr(Expression, Func):
+    arg_types = {
+        "this": True,
+        "expression": True,
+        "position": False,
+        "occurrence": False,
+        "parameters": False,
+        "group": False,
+    }
+
+
 # Hashing / cryptographic
 
 

{sqlglotc-30.12.0 → sqlglotc-30.13.0}/sqlglot/expressions/temporal.py

@@ -106,7 +106,7 @@ class DatetimeAdd(Expression, Func, IntervalOp):
 
 
 class DatetimeDiff(Expression, Func, TimeUnit):
-    arg_types = {"this": True, "expression": True, "unit": False}
+    arg_types = {"this": True, "expression": True, "unit": False, "date_part_boundary": False}
 
 
 class DatetimeSub(Expression, Func, IntervalOp):
@@ -441,6 +441,10 @@ class FromISO8601Date(Expression, Func):
     _sql_names = ["FROM_ISO8601_DATE"]
 
 
+class FromISO8601TimestampNanos(Expression, Func):
+    _sql_names = ["FROM_ISO8601_TIMESTAMP_NANOS"]
+
+
 class ParseDatetime(Expression, Func):
     arg_types = {"this": True, "format": False, "zone": False, "default_year": False}
 
@@ -450,11 +454,18 @@ class ParseTime(Expression, Func):
 
 
 class StrToDate(Expression, Func):
-    arg_types = {"this": True, "format": False, "safe": False}
+    arg_types = {"this": True, "format": False, "safe": False, "default_year": False}
 
 
 class StrToTime(Expression, Func):
-    arg_types = {"this": True, "format": True, "zone": False, "safe": False, "target_type": False}
+    arg_types = {
+        "this": True,
+        "format": True,
+        "zone": False,
+        "safe": False,
+        "target_type": False,
+        "default_year": False,
+    }
 
 
 class StrToUnix(Expression, Func):

{sqlglotc-30.12.0 → sqlglotc-30.13.0}/sqlglot/generator.py

@@ -402,9 +402,6 @@ class Generator:
     # UNNEST WITH ORDINALITY (presto) instead of UNNEST WITH OFFSET (bigquery)
     UNNEST_WITH_ORDINALITY = True
 
-    # Whether FILTER (WHERE cond) can be used for conditional aggregation
-    AGGREGATE_FILTER_SUPPORTED = True
-
     # Whether JOIN sides (LEFT, RIGHT) are supported in conjunction with SEMI/ANTI join kinds
     SEMI_ANTI_JOIN_WITH_SIDE = True
 
@@ -429,6 +426,9 @@ class Generator:
     # The keyword to use when specifying the seed of a sample clause
     TABLESAMPLE_SEED_KEYWORD = "SEED"
 
+    # Whether the historical data clause (AT ... / BEFORE ...) is generated after the table alias
+    HISTORICAL_DATA_POST_ALIAS = False
+
     # Whether COLLATE is a function instead of a binary operator
     COLLATE_IS_FUNC = False
 
@@ -1905,16 +1905,9 @@ class Generator:
         return f"{percent}{rows}{with_ties}"
 
     def filter_sql(self, expression: exp.Filter) -> str:
-        if self.AGGREGATE_FILTER_SUPPORTED:
-            this = self.sql(expression, "this")
-            where = self.sql(expression, "expression").strip()
-            return f"{this} FILTER({where})"
-
-        agg = expression.this
-        agg_arg = agg.this
-        cond = expression.expression.this
-        agg_arg.replace(exp.If(this=cond.copy(), true=agg_arg.copy()))
-        return self.sql(agg)
+        this = self.sql(expression, "this")
+        where = self.sql(expression, "expression").strip()
+        return f"{this} FILTER({where})"
 
     def hint_sql(self, expression: exp.Hint) -> str:
         if not self.QUERY_HINTS:
@@ -2433,7 +2426,10 @@ class Generator:
 
         when = self.sql(expression, "when")
         if when:
-            table = f"{table} {when}"
+            if self.HISTORICAL_DATA_POST_ALIAS:
+                alias = f"{alias} {when}"
+            else:
+                table = f"{table} {when}"
 
         changes = self.sql(expression, "changes")
         changes = f" {changes}" if changes else ""
@@ -3243,7 +3239,12 @@ class Generator:
         limit = expression.args.get("limit")
 
         if self.LIMIT_FETCH == "LIMIT" and isinstance(limit, exp.Fetch):
-            limit = exp.Limit(expression=exp.maybe_copy(limit.args.get("count")))
+            count = limit.args.get("count")
+            # "FETCH FIRST ROWS ONLY" without a count means one row per the SQL
+            # standard; emitting a bare "LIMIT" here would produce invalid SQL.
+            limit = exp.Limit(
+                expression=exp.maybe_copy(count) if count is not None else exp.Literal.number(1)
+            )
         elif self.LIMIT_FETCH == "FETCH" and isinstance(limit, exp.Limit):
             limit = exp.Fetch(direction="FIRST", count=exp.maybe_copy(limit.expression))
 
@@ -3723,6 +3724,10 @@ class Generator:
         options = f" {options}" if options else ""
         return f"PRIMARY KEY{this} ({expressions}){include}{options}"
 
+    def timeserieskey_sql(self, expression: exp.TimeseriesKey) -> str:
+        self.unsupported("TIMESERIES primary key columns are not supported")
+        return self.sql(expression, "this")
+
     def if_sql(self, expression: exp.If) -> str:
         return self.case_sql(exp.Case(ifs=[expression], default=expression.args.get("false")))
 
@@ -4008,6 +4013,9 @@ class Generator:
     def fromiso8601timestamp_sql(self, expression: exp.FromISO8601Timestamp) -> str:
         return self.sql(exp.cast(expression.this, exp.DType.TIMESTAMPTZ))
 
+    def fromiso8601timestampnanos_sql(self, expression: exp.FromISO8601TimestampNanos) -> str:
+        return self.sql(exp.cast(expression.this, exp.DType.TIMESTAMPTZ))
+
     def add_sql(self, expression: exp.Add) -> str:
         return self.binary(expression, "+")
 
@@ -4087,6 +4095,10 @@ class Generator:
     def strtotime_sql(self, expression: exp.StrToTime) -> str:
         return self.func("STR_TO_TIME", expression.this, expression.args.get("format"))
 
+    # Base implementation that excludes the safe and default_year metadata args
+    def strtodate_sql(self, expression: exp.StrToDate) -> str:
+        return self.func("STR_TO_DATE", expression.this, expression.args.get("format"))
+
     def parsedatetime_sql(self, expression: exp.ParseDatetime) -> str:
         return self.func(
             "PARSE_DATETIME",

{sqlglotc-30.12.0 → sqlglotc-30.13.0}/sqlglot/generators/bigquery.py

@@ -137,6 +137,34 @@ def _pushdown_cte_column_names(expression: exp.Expr) -> exp.Expr:
     return expression
 
 
+def _unnest_explode_generate_series(expression: exp.Expr) -> exp.Expr:
+    """
+    Rewrites exploding GENERATE_SERIES projections into table references, e.g.
+
+        SELECT GENERATE_SERIES(1, 2) AS x           -> SELECT x FROM GENERATE_SERIES(1, 2) AS x
+        SELECT y, GENERATE_SERIES(1, 2) AS x FROM t -> SELECT y, x FROM t CROSS JOIN GENERATE_SERIES(1, 2) AS x
+
+    since BigQuery can't explode in the projection and must unnest it in the FROM clause instead.
+    The resulting table reference is unnested downstream by `transforms.unnest_generate_series`.
+    """
+    if isinstance(expression, exp.Select):
+        for projection in expression.selects:
+            if isinstance(series := projection.unalias(), exp.ExplodingGenerateSeries):
+                column_name = projection.output_name or "_gen_series_value"
+
+                projection.replace(exp.column(column_name))
+                table = exp.Table(
+                    this=series, alias=exp.TableAlias(this=exp.to_identifier(column_name))
+                )
+
+                if expression.args.get("from_"):
+                    expression.join(table, copy=False, join_type="CROSS")
+                else:
+                    expression.set("from_", exp.From(this=table))
+
+    return expression
+
+
 def _array_contains_sql(self: BigQueryGenerator, expression: exp.ArrayContains) -> str:
     return self.sql(
         exp.Exists(
@@ -358,6 +386,7 @@ class BigQueryGenerator(generator.Generator):
         exp.ParseDatetime: lambda self, e: self.func("PARSE_DATETIME", self.format_time(e), e.this),
         exp.Select: transforms.preprocess(
             [
+                _unnest_explode_generate_series,
                 transforms.explode_projection_to_unnest(),
                 transforms.unqualify_unnest,
                 transforms.eliminate_distinct_on,
@@ -379,6 +408,7 @@ class BigQueryGenerator(generator.Generator):
         exp.StrToDate: _str_to_datetime_sql,
         exp.StrToTime: _str_to_datetime_sql,
         exp.SessionUser: lambda *_: "SESSION_USER()",
+        exp.Table: transforms.preprocess([transforms.unnest_generate_series]),
         exp.TimeAdd: date_add_interval_sql("TIME", "ADD"),
         exp.TimeFromParts: rename_func("TIME"),
         exp.TimestampFromParts: rename_func("DATETIME"),

{sqlglotc-30.12.0 → sqlglotc-30.13.0}/sqlglot/generators/databricks.py

@@ -57,6 +57,9 @@ class DatabricksGenerator(SparkGenerator):
             exp.CurrentCatalog: lambda *_: "CURRENT_CATALOG()",
             exp.RegexpLike: None,
             exp.TryCast: None,
+            exp.RegrAvgx: lambda self, e: self._regr_sql(e),
+            exp.RegrSxx: lambda self, e: self._regr_sql(e),
+            exp.RegrSyy: lambda self, e: self._regr_sql(e),
         }.items()
         if v is not None
     }
@@ -90,6 +93,9 @@ class DatabricksGenerator(SparkGenerator):
 
         return super().columndef_sql(expression, sep)
 
+    def timeserieskey_sql(self, expression: exp.TimeseriesKey) -> str:
+        return f"{self.sql(expression, 'this')} TIMESERIES"
+
     def jsonpath_sql(self, expression: exp.JSONPath) -> str:
         expression.set("escape", None)
         path = super().jsonpath_sql(expression)
@@ -109,6 +115,13 @@ class DatabricksGenerator(SparkGenerator):
 
         return self.func("UNIFORM", expression.this, expression.expression, seed)
 
+    def _regr_sql(self, expression: exp.RegrAvgx | exp.RegrSxx | exp.RegrSyy) -> str:
+        name = expression.sql_name()
+        x = expression.expression
+        if isinstance(x, exp.Distinct):
+            return self.func(name, exp.Distinct(expressions=[expression.this]), *x.expressions)
+        return self.func(name, expression.this, x)
+
     def clusterproperty_sql(self, expression):
         this = self.sql(expression, "this") or f"({self.expressions(expression, flat=True)})"
         return f"CLUSTER BY {this}"

sqlglotc-30.13.0/sqlglot/generators/dax.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+from sqlglot import generator
+
+
+class DAXGenerator(generator.Generator):
+    AFTER_HAVING_MODIFIER_TRANSFORMS = generator.AFTER_HAVING_MODIFIER_TRANSFORMS

{sqlglotc-30.12.0 → sqlglotc-30.13.0}/sqlglot/generators/dremio.py

@@ -72,6 +72,14 @@ class DremioGenerator(generator.Generator):
         exp.GenerateSeries: rename_func("ARRAY_GENERATE_RANGE"),
     }
 
+    def version_sql(self, expression: exp.Version) -> str:
+        if expression.text("kind") == "AS OF":
+            this = "SNAPSHOT" if expression.name == "VERSION" else expression.name
+            return f"AT {this} {self.sql(expression, 'expression')}"
+
+        self.unsupported("Range time travel is not supported in Dremio")
+        return super().version_sql(expression)
+
     def datatype_sql(self, expression: exp.DataType) -> str:
         """
         Reject time-zone-aware TIMESTAMPs, which Dremio does not accept

{sqlglotc-30.12.0 → sqlglotc-30.13.0}/sqlglot/generators/drill.py

@@ -29,6 +29,7 @@ class DrillGenerator(generator.Generator):
     TRY_SUPPORTED = False
     SUPPORTS_UESCAPE = False
     SUPPORTS_DECODE_CASE = False
+    SUPPORTS_LIKE_QUANTIFIERS = False
 
     AFTER_HAVING_MODIFIER_TRANSFORMS = generator.AFTER_HAVING_MODIFIER_TRANSFORMS
 
@@ -76,7 +77,6 @@ class DrillGenerator(generator.Generator):
         exp.If: lambda self, e: (
             f"`IF`({self.format_args(e.this, e.args.get('true'), e.args.get('false'))})"
         ),
-        exp.ILike: lambda self, e: self.binary(e, "`ILIKE`"),
         exp.Levenshtein: unsupported_args("ins_cost", "del_cost", "sub_cost", "max_dist")(
             rename_func("LEVENSHTEIN_DISTANCE")
         ),
@@ -104,6 +104,22 @@ class DrillGenerator(generator.Generator):
         ),
     }
 
+    def ilike_sql(self, expression: exp.ILike) -> str:
+        if isinstance(expression.expression, (exp.All, exp.Any)):
+            return super().ilike_sql(expression)
+        return self._ilike_func_sql(expression)
+
+    def escape_sql(self, expression: exp.Escape) -> str:
+        # Drill takes the escape character as ILIKE's third argument instead of an ESCAPE clause
+        this = expression.this
+        if isinstance(this, exp.ILike) and not isinstance(this.expression, (exp.All, exp.Any)):
+            return self._ilike_func_sql(this, expression.expression)
+        return super().escape_sql(expression)
+
+    def _ilike_func_sql(self, expression: exp.ILike, escape: exp.Expr | None = None) -> str:
+        ilike = self.func("ILIKE", expression.this, expression.expression, escape)
+        return f"NOT {ilike}" if expression.args.get("negate") else ilike
+
 
 def _drill_dateint_format() -> str:
     from sqlglot.dialects.drill import Drill

{sqlglotc-30.12.0 → sqlglotc-30.13.0}/sqlglot/generators/duckdb.py

@@ -32,9 +32,10 @@ from sqlglot.dialects.dialect import (
     rename_func,
     remove_from_array_using_filter,
     strposition_sql,
-    str_to_time_sql,
     timestrtotime_sql,
     unit_to_str,
+    week_unit_to_dow,
+    WEEK_START_DAY_TO_DOW,
 )
 from sqlglot.generator import unsupported_args
 from sqlglot.helper import find_new_name, is_date_unit, seq_get
@@ -69,18 +70,6 @@ WS_CONTROL_CHARS_TO_DUCK = {
     "\u001f": 31,
 }
 
-# Days of week to ISO 8601 day-of-week numbers
-# ISO 8601 standard: Monday=1, Tuesday=2, Wednesday=3, Thursday=4, Friday=5, Saturday=6, Sunday=7
-WEEK_START_DAY_TO_DOW = {
-    "MONDAY": 1,
-    "TUESDAY": 2,
-    "WEDNESDAY": 3,
-    "THURSDAY": 4,
-    "FRIDAY": 5,
-    "SATURDAY": 6,
-    "SUNDAY": 7,
-}
-
 MAX_BIT_POSITION = exp.Literal.number(32768)
 
 # cs/as/ps are Snowflake defaults; DuckDB already behaves the same way, so they are safe to drop.
@@ -906,33 +895,6 @@ def _implicit_datetime_cast(
     return arg
 
 
-def _week_unit_to_dow(unit: exp.Expr | None) -> int | None:
-    """
-    Compute the Monday-based day shift to align DATE_DIFF('WEEK', ...) coming
-    from other dialects, e.g BigQuery's WEEK(<day>) or ISOWEEK unit parts.
-
-    Args:
-        unit: The unit expression (Var for ISOWEEK or WeekStart)
-
-    Returns:
-        The ISO 8601 day number (Monday=1, Sunday=7 etc) or None if not a week unit or if day is dynamic (not a constant).
-
-        Examples:
-            "WEEK(SUNDAY)" -> 7
-            "WEEK(MONDAY)" -> 1
-            "ISOWEEK" -> 1
-    """
-    # Handle plain Var expressions for ISOWEEK only
-    if isinstance(unit, exp.Var) and unit.name.upper() in "ISOWEEK":
-        return 1
-
-    # Handle WeekStart expressions with explicit day
-    if isinstance(unit, exp.WeekStart):
-        return WEEK_START_DAY_TO_DOW.get(unit.name.upper())
-
-    return None
-
-
 def _build_week_trunc_expression(
     date_expr: exp.Expr,
     start_dow: int,
@@ -989,7 +951,7 @@ def _date_diff_sql(self: DuckDBGenerator, expression: exp.DateDiff | exp.Datetim
     date_part_boundary = expression.args.get("date_part_boundary")
 
     # Extract week start day; returns None if day is dynamic (column/placeholder)
-    week_start = _week_unit_to_dow(unit)
+    week_start = week_unit_to_dow(unit)
     if date_part_boundary and week_start and this and expr:
         expression.set("unit", exp.Literal.string("WEEK"))
 
@@ -1606,6 +1568,7 @@ class DuckDBGenerator(generator.Generator):
     ARRAY_SIZE_DIM_REQUIRED: bool | None = False
     NORMALIZE_EXTRACT_DATE_PARTS = True
     SUPPORTS_LIKE_QUANTIFIERS = False
+    HISTORICAL_DATA_POST_ALIAS = True
     SET_ASSIGNMENT_REQUIRES_VARIABLE_KEYWORD = True
 
     TRANSFORMS = {
@@ -2751,14 +2714,13 @@ class DuckDBGenerator(generator.Generator):
             exp.DType.TIMESTAMPTZ,
         )
 
+        value, formatted_time = self._strptime_default_year(expression)
+
         if expression.args.get("safe"):
-            formatted_time = self.format_time(expression)
             cast_type = exp.DType.TIMESTAMPTZ if needs_tz else exp.DType.TIMESTAMP
-            return self.sql(
-                exp.cast(self.func("TRY_STRPTIME", expression.this, formatted_time), cast_type)
-            )
+            return self.sql(exp.cast(self.func("TRY_STRPTIME", value, formatted_time), cast_type))
 
-        base_sql = str_to_time_sql(self, expression)
+        base_sql = self.func("STRPTIME", value, formatted_time)
         if needs_tz:
             return self.sql(
                 exp.cast(
@@ -2769,27 +2731,30 @@ class DuckDBGenerator(generator.Generator):
         return base_sql
 
     def strtodate_sql(self, expression: exp.StrToDate) -> str:
-        formatted_time = self.format_time(expression)
+        value, formatted_time = self._strptime_default_year(expression)
         function_name = "STRPTIME" if not expression.args.get("safe") else "TRY_STRPTIME"
         return self.sql(
             exp.cast(
-                self.func(function_name, expression.this, formatted_time),
+                self.func(function_name, value, formatted_time),
                 exp.DataType(this=exp.DType.DATE),
             )
         )
 
-    def parsedatetime_sql(self, expression: exp.ParseDatetime) -> str:
-        formatted_time = self.format_time(expression)
+    def _strptime_default_year(
+        self, expression: exp.StrToTime | exp.StrToDate | exp.ParseDatetime
+    ) -> tuple[exp.ExpOrStr, exp.ExpOrStr | None]:
+        value: exp.ExpOrStr = expression.this
+        formatted_time: exp.ExpOrStr | None = self.format_time(expression)
 
-        default_year = expression.args.get("default_year")
-        if default_year:
-            year_str = exp.Literal.string(f"{default_year.name} ")
-            fmt_prefix = exp.Literal.string("%Y ")
-            value = exp.DPipe(this=year_str, expression=expression.this)
-            fmt = exp.DPipe(this=fmt_prefix, expression=formatted_time)
-            return self.func("STRPTIME", value, fmt)
+        if default_year := expression.args.get("default_year"):
+            value = exp.DPipe(this=exp.Literal.string(f"{default_year.name} "), expression=value)
+            formatted_time = exp.DPipe(this=exp.Literal.string("%Y "), expression=formatted_time)
 
-        return self.func("STRPTIME", expression.this, formatted_time)
+        return value, formatted_time
+
+    def parsedatetime_sql(self, expression: exp.ParseDatetime) -> str:
+        value, formatted_time = self._strptime_default_year(expression)
+        return self.func("STRPTIME", value, formatted_time)
 
     def parsetime_sql(self, expression: exp.ParseTime) -> str:
         formatted_time = self.format_time(expression)
@@ -3152,6 +3117,11 @@ class DuckDBGenerator(generator.Generator):
 
     def countif_sql(self, expression: exp.CountIf) -> str:
         if self.dialect.version >= (1, 2):
+            this = expression.this
+            if expression.args.get("zero_on_all_null") and not isinstance(this, exp.Distinct):
+                # DuckDB >= 1.2's COUNT_IF returns NULL when the condition is NULL on all rows,
+                # so we wrap the condition in IS TRUE to preserve count-like semantics
+                expression = exp.CountIf(this=exp.paren(this).is_(exp.true()))
             return self.function_fallback_sql(expression)
 
         # https://github.com/tobymao/sqlglot/pull/4749
@@ -4383,7 +4353,7 @@ class DuckDBGenerator(generator.Generator):
         unit = expression.args.get("unit")
         date = expression.this
 
-        week_start = _week_unit_to_dow(unit)
+        week_start = week_unit_to_dow(unit)
         unit = unit_to_str(expression)
 
         if week_start: