sqlglot 30.23.0__tar.gz → 30.24.0__tar.gz

{sqlglot-30.23.0 → sqlglot-30.24.0}/CHANGELOG.md

@@ -1,6 +1,70 @@
 Changelog
 =========
 
+## [v30.23.0] - 2026-10-14
+### :boom: BREAKING CHANGES
+- due to [`cf39265`](https://github.com/tobymao/sqlglot/commit/cf39265a3e8efd8c32bab7f9c9b4f123fdfbf682) - hash flag for case-sensitive nodes [CLAUDE] *(PR [#8599](https://github.com/tobymao/sqlglot/pull/8599) by [@laravioli](https://github.com/laravioli))*:
+
+  hash flag for case-sensitive nodes [CLAUDE] (#8599)
+
+- due to [`4d7d7ca`](https://github.com/tobymao/sqlglot/commit/4d7d7ca94250269dc1903d7175b7b8aa96e9a480) - generate JSONExtractRaw for JSON-valued extraction *(PR [#8601](https://github.com/tobymao/sqlglot/pull/8601) by [@ebarkhordar](https://github.com/ebarkhordar))*:
+
+  generate JSONExtractRaw for JSON-valued extraction (#8601)
+
+- due to [`623dc88`](https://github.com/tobymao/sqlglot/commit/623dc8889ba7bffa9b006fd1d1641715b73d5ce4) - infer correct types for temporal interval arithmetic *(PR [#8622](https://github.com/tobymao/sqlglot/pull/8622) by [@georgesittas](https://github.com/georgesittas))*:
+
+  infer correct types for temporal interval arithmetic (#8622)
+
+
+### :sparkles: New Features
+- [`8abe7f8`](https://github.com/tobymao/sqlglot/commit/8abe7f8382c80f95cb1e5a8a985969f6c11fd03a) - **starrocks**: parse TIME_SLICE into exp.TimeSlice [CLAUDE] *(PR [#8555](https://github.com/tobymao/sqlglot/pull/8555) by [@nytai](https://github.com/nytai))*
+- [`f3a6eb9`](https://github.com/tobymao/sqlglot/commit/f3a6eb95e424ef03bf20fca05a0431a666946e90) - **doris**: parse full-text search operators [CLAUDE] *(PR [#8585](https://github.com/tobymao/sqlglot/pull/8585) by [@kaya-abdullah](https://github.com/kaya-abdullah))*
+  - :arrow_lower_right: *addresses issue [#8584](https://github.com/tobymao/sqlglot/issues/8584) opened by [@kaya-abdullah](https://github.com/kaya-abdullah)*
+- [`3ba19ee`](https://github.com/tobymao/sqlglot/commit/3ba19eedd7b381f990f9926266457eda7a60095b) - **starrocks**: support AGGREGATE KEY tables [CLAUDE] *(PR [#8591](https://github.com/tobymao/sqlglot/pull/8591) by [@nytai](https://github.com/nytai))*
+- [`9114355`](https://github.com/tobymao/sqlglot/commit/9114355463fd02a9b505c869edb0561503a07b19) - **mysql**: Allow constraints without names. *(PR [#8600](https://github.com/tobymao/sqlglot/pull/8600) by [@burnison](https://github.com/burnison))*
+- [`6202d94`](https://github.com/tobymao/sqlglot/commit/6202d94764305621117dc6229cda79575ca103e5) - **starrocks**: support HLL columns and the HLL_UNION aggregation type [CLAUDE] *(PR [#8612](https://github.com/tobymao/sqlglot/pull/8612) by [@nytai](https://github.com/nytai))*
+- [`0b00178`](https://github.com/tobymao/sqlglot/commit/0b0017821590b08497529d37387396adb6c3aa5b) - **spark**: parse all ALTER TABLE DROP COLUMN[S] forms [CLAUDE] *(PR [#8611](https://github.com/tobymao/sqlglot/pull/8611) by [@tsamaras](https://github.com/tsamaras))*
+- [`59a96d8`](https://github.com/tobymao/sqlglot/commit/59a96d868a6b8ed114ac3e216201106fea8bc351) - **starrocks**: support REFRESH MATERIALIZED VIEW options [CLAUDE] *(PR [#8613](https://github.com/tobymao/sqlglot/pull/8613) by [@nytai](https://github.com/nytai))*
+- [`676ba36`](https://github.com/tobymao/sqlglot/commit/676ba365497215dadf89c3fa57f4872529745650) - **mysql**: Support named `FOREIGN KEY` indexes. *(PR [#8615](https://github.com/tobymao/sqlglot/pull/8615) by [@burnison](https://github.com/burnison))*
+- [`b679d0c`](https://github.com/tobymao/sqlglot/commit/b679d0cf8cad5bab7bb5004d9b8f8ce51d542b42) - **databricks**: match_recognize support closes [#8617](https://github.com/tobymao/sqlglot/pull/8617) *(commit by [@georgesittas](https://github.com/georgesittas))*
+
+### :bug: Bug Fixes
+- [`a00dc2e`](https://github.com/tobymao/sqlglot/commit/a00dc2e5c489214bea53bacbbeba8713f21ebce1) - **postgres**: improve json_value support closes [#8579](https://github.com/tobymao/sqlglot/pull/8579) *(commit by [@georgesittas](https://github.com/georgesittas))*
+- [`ffb9721`](https://github.com/tobymao/sqlglot/commit/ffb9721df98984c62817701ec8cd895cb3b1ee82) - **oracle**: tokenize q'...' quoted string literals [CLAUDE] *(PR [#8582](https://github.com/tobymao/sqlglot/pull/8582) by [@DylanMerigaud](https://github.com/DylanMerigaud))*
+- [`e237d59`](https://github.com/tobymao/sqlglot/commit/e237d5980e8084cd2eceb874280efc3f3369c0ba) - **optimizer**: keep the alias outside of COALESCE when unnesting a COUNT subquery [CLAUDE] *(PR [#8589](https://github.com/tobymao/sqlglot/pull/8589) by [@anishmehta24](https://github.com/anishmehta24))*
+- [`98bedf6`](https://github.com/tobymao/sqlglot/commit/98bedf649b244d321782a213944320d54f7cc868) - **oracle**: parse partition clauses and flashback queries [CODEX] *(PR [#8588](https://github.com/tobymao/sqlglot/pull/8588) by [@yousefissa](https://github.com/yousefissa))*
+  - :arrow_lower_right: *fixes issue [#8587](https://github.com/tobymao/sqlglot/issues/8587) opened by [@cofin](https://github.com/cofin)*
+- [`09481ce`](https://github.com/tobymao/sqlglot/commit/09481cec085106bc77fb584e4d322f7e179a5a11) - **optimizer**: qualify bare USING columns after SEMI/ANTI JOIN closes [#8590](https://github.com/tobymao/sqlglot/pull/8590) *(PR [#8592](https://github.com/tobymao/sqlglot/pull/8592) by [@ansh-rohilla](https://github.com/ansh-rohilla))*
+  - :arrow_lower_right: *fixes issue [#8590](https://github.com/tobymao/sqlglot/issues/8590) opened by [@jackr-xceleration](https://github.com/jackr-xceleration)*
+- [`df0a300`](https://github.com/tobymao/sqlglot/commit/df0a3006c485010e2bde4f2b6ce16594885772f0) - **duckdb**: append on 1-based ARRAY_INSERT -1 *(PR [#8597](https://github.com/tobymao/sqlglot/pull/8597) by [@siddharthsarda](https://github.com/siddharthsarda))*
+- [`7d9a6cd`](https://github.com/tobymao/sqlglot/commit/7d9a6cd599c41e4bd886c757e1b9e60b39bef70c) - allow `EXTERNAL FUNCTION` in Athena `CTAS` *(PR [#8602](https://github.com/tobymao/sqlglot/pull/8602) by [@matthias-Q](https://github.com/matthias-Q))*
+- [`e38929e`](https://github.com/tobymao/sqlglot/commit/e38929edd78a20f74fc19fee819e14ac23add687) - **teradata**: default window aggregate frame to the whole partition [CLAUDE] *(PR [#8596](https://github.com/tobymao/sqlglot/pull/8596) by [@bhuvan-uda](https://github.com/bhuvan-uda))*
+  - :arrow_lower_right: *fixes issue [#8595](https://github.com/tobymao/sqlglot/issues/8595) opened by [@bhuvan-uda](https://github.com/bhuvan-uda)*
+- [`cf39265`](https://github.com/tobymao/sqlglot/commit/cf39265a3e8efd8c32bab7f9c9b4f123fdfbf682) - **expressions**: hash flag for case-sensitive nodes [CLAUDE] *(PR [#8599](https://github.com/tobymao/sqlglot/pull/8599) by [@laravioli](https://github.com/laravioli))*
+  - :arrow_lower_right: *fixes issue [#8598](https://github.com/tobymao/sqlglot/issues/8598) opened by [@laravioli](https://github.com/laravioli)*
+- [`ab0a291`](https://github.com/tobymao/sqlglot/commit/ab0a291f91f1ba8c32058340bf76738c4ea685ea) - **oracle**: normalize flashback timestamps and simplify parsing *(PR [#8608](https://github.com/tobymao/sqlglot/pull/8608) by [@georgesittas](https://github.com/georgesittas))*
+- [`a0cc28b`](https://github.com/tobymao/sqlglot/commit/a0cc28b91c3d186801d478e83967e967b86c90dd) - **doris**: round-trip MATCH operands and quoted analyzers *(PR [#8607](https://github.com/tobymao/sqlglot/pull/8607) by [@georgesittas](https://github.com/georgesittas))*
+- [`4d7d7ca`](https://github.com/tobymao/sqlglot/commit/4d7d7ca94250269dc1903d7175b7b8aa96e9a480) - **clickhouse**: generate JSONExtractRaw for JSON-valued extraction *(PR [#8601](https://github.com/tobymao/sqlglot/pull/8601) by [@ebarkhordar](https://github.com/ebarkhordar))*
+- [`1f8d15b`](https://github.com/tobymao/sqlglot/commit/1f8d15bbd68586704666533b21a5b35d710d68f0) - convert DuckDB ARRAY_SLICE endpoints to SLICE lengths *(PR [#8609](https://github.com/tobymao/sqlglot/pull/8609) by [@georgesittas](https://github.com/georgesittas))*
+- [`61c3ca4`](https://github.com/tobymao/sqlglot/commit/61c3ca4479c167d9c90d51f73184568769fa0635) - **oracle**: parse CREATE TABLE TABLESPACE *(PR [#8605](https://github.com/tobymao/sqlglot/pull/8605) by [@cmodiano](https://github.com/cmodiano))*
+- [`08f2405`](https://github.com/tobymao/sqlglot/commit/08f2405cfddc874f4366cbcca9e25233fcb11281) - **oracle**: expand alternative quoting and support national literals *(PR [#8606](https://github.com/tobymao/sqlglot/pull/8606) by [@georgesittas](https://github.com/georgesittas))*
+  - :arrow_lower_right: *fixes issue [#8580](https://github.com/tobymao/sqlglot/issues/8580) opened by [@cmodiano](https://github.com/cmodiano)*
+- [`5b949bd`](https://github.com/tobymao/sqlglot/commit/5b949bd6b7f1db1474a87ac34d3a9246fa7de237) - **oracle**: parse CREATE TABLE physical attributes and storage clauses closes [#8581](https://github.com/tobymao/sqlglot/pull/8581) *(commit by [@georgesittas](https://github.com/georgesittas))*
+- [`ba643d3`](https://github.com/tobymao/sqlglot/commit/ba643d33285475774c3253551e1ed18ac89e6c22) - **clickhouse**: transpile RegexpCount to countMatches [CLAUDE] *(PR [#8616](https://github.com/tobymao/sqlglot/pull/8616) by [@ekut](https://github.com/ekut))*
+- [`623dc88`](https://github.com/tobymao/sqlglot/commit/623dc8889ba7bffa9b006fd1d1641715b73d5ce4) - **duckdb**: infer correct types for temporal interval arithmetic *(PR [#8622](https://github.com/tobymao/sqlglot/pull/8622) by [@georgesittas](https://github.com/georgesittas))*
+- [`b1b244b`](https://github.com/tobymao/sqlglot/commit/b1b244b1f38a3000c94a7b21ee6dfae1959dd4b2) - **optimizer**: qualify columns for SPLIT_TO_TABLE *(PR [#8625](https://github.com/tobymao/sqlglot/pull/8625) by [@andrjohns](https://github.com/andrjohns))*
+- [`e92c222`](https://github.com/tobymao/sqlglot/commit/e92c22287ff73a66e9dece115acedb81133f0dbf) - **duckdb**: cast array elements to text before applying the ARRAY_TO_STRING null replacement [CLAUDE] *(PR [#8627](https://github.com/tobymao/sqlglot/pull/8627) by [@anishmehta24](https://github.com/anishmehta24))*
+- [`fbda0b9`](https://github.com/tobymao/sqlglot/commit/fbda0b91481d679f17844af15fb998cc559533be) - **parser**: keep the whole statement when REFRESH falls back to a cmd *(PR [#8621](https://github.com/tobymao/sqlglot/pull/8621) by [@nytai](https://github.com/nytai))*
+- [`fdba492`](https://github.com/tobymao/sqlglot/commit/fdba492cec5a1fbe012add7f1aed18f46739c2a3) - **optimizer**: include semi/anti join refs when identifying alias collisions *(PR [#8623](https://github.com/tobymao/sqlglot/pull/8623) by [@treysp](https://github.com/treysp))*
+- [`2c7b928`](https://github.com/tobymao/sqlglot/commit/2c7b928071ed32e72b218011a1a3c011dba26b24) - **athena**: route by each engine's rules when the combined tokenizer fails [CLAUDE] *(PR [#8629](https://github.com/tobymao/sqlglot/pull/8629) by [@masiljangajji](https://github.com/masiljangajji))*
+  - :arrow_lower_right: *fixes issue [#8628](https://github.com/tobymao/sqlglot/issues/8628) opened by [@masiljangajji](https://github.com/masiljangajji)*
+- [`ad8764a`](https://github.com/tobymao/sqlglot/commit/ad8764a0436a7b5c500b783ebe50dbf20c1e477c) - keep a replacement's grouping in replace_placeholders *(PR [#8624](https://github.com/tobymao/sqlglot/pull/8624) by [@tobymao](https://github.com/tobymao))*
+
+### :wrench: Chores
+- [`579789d`](https://github.com/tobymao/sqlglot/commit/579789dc3d368daf6aa0919ed5c0994187472a4b) - add support for Python 3.15 *(PR [#8586](https://github.com/tobymao/sqlglot/pull/8586) by [@Viicos](https://github.com/Viicos))*
+- [`c0a9457`](https://github.com/tobymao/sqlglot/commit/c0a945740e55facdc7120c17cda2771dc55c7903) - **mysql**: tests for named FOREIGN KEY indexes *(commit by [@geooo109](https://github.com/geooo109))*
+
+
 ## [v30.22.0] - 2026-10-09
 ### :boom: BREAKING CHANGES
 - due to [`5d997d9`](https://github.com/tobymao/sqlglot/commit/5d997d94d8041ed12db5abe7a1155b30df057b43) - Parse bare `ALTER TABLE ... DROP c`. *(PR [#8432](https://github.com/tobymao/sqlglot/pull/8432) by [@burnison](https://github.com/burnison))*:
@@ -16239,3 +16303,4 @@ pip install "sqlglot[c]"   # compiled — faster, but no subclassing
 [v30.20.0]: https://github.com/tobymao/sqlglot/compare/v30.19.0...v30.20.0
 [v30.21.0]: https://github.com/tobymao/sqlglot/compare/v30.20.0...v30.21.0
 [v30.22.0]: https://github.com/tobymao/sqlglot/compare/v30.21.0...v30.22.0
+[v30.23.0]: https://github.com/tobymao/sqlglot/compare/v30.22.0...v30.23.0

{sqlglot-30.23.0/sqlglot.egg-info → sqlglot-30.24.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlglot
-Version: 30.23.0
+Version: 30.24.0
 Summary: An easily customizable SQL parser and transpiler
 Author-email: Toby Mao <toby.mao@gmail.com>
 License-Expression: MIT
@@ -34,10 +34,10 @@ Requires-Dist: types-pytz; extra == "dev"
 Requires-Dist: typing_extensions; extra == "dev"
 Requires-Dist: pyperf; extra == "dev"
 Provides-Extra: c
-Requires-Dist: sqlglotc==30.23.0; python_version >= "3.10" and extra == "c"
+Requires-Dist: sqlglotc==30.24.0; python_version >= "3.10" and extra == "c"
 Provides-Extra: rs
 Requires-Dist: sqlglotrs==0.13.0; extra == "rs"
-Requires-Dist: sqlglotc==30.23.0; python_version >= "3.10" and extra == "rs"
+Requires-Dist: sqlglotc==30.24.0; python_version >= "3.10" and extra == "rs"
 Dynamic: license-file
 Dynamic: provides-extra
 

{sqlglot-30.23.0 → sqlglot-30.24.0}/sqlglot/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '30.23.0'
-__version_tuple__ = version_tuple = (30, 23, 0)
+__version__ = version = '30.24.0'
+__version_tuple__ = version_tuple = (30, 24, 0)
 
-__commit_id__ = commit_id = 'gad8764a04'
+__commit_id__ = commit_id = 'g5d588c0f3'

{sqlglot-30.23.0 → sqlglot-30.24.0}/sqlglot/dialects/clickhouse.py

@@ -116,6 +116,7 @@ class ClickHouse(Dialect):
             "UINT8": TokenType.UTINYINT,
             "IPV4": TokenType.IPV4,
             "IPV6": TokenType.IPV6,
+            "PASTE": TokenType.PASTE,
             "POINT": TokenType.POINT,
             "PROJECTION": TokenType.PROJECTION,
             "RING": TokenType.RING,

{sqlglot-30.23.0 → sqlglot-30.24.0}/sqlglot/dialects/dialect.py

@@ -2140,7 +2140,10 @@ def is_parse_json(expression: exp.Expr) -> bool:
 
 
 def isnull_to_is_null(args: BuilderArgs) -> exp.Expr:
-    return exp.Paren(this=exp.Is(this=seq_get(args, 0), expression=exp.null()))
+    this = seq_get(args, 0)
+    if isinstance(this, (exp.Predicate, exp.Connector, exp.Not)):
+        this = exp.Paren(this=this)
+    return exp.Paren(this=exp.Is(this=this, expression=exp.null()))
 
 
 def generatedasidentitycolumnconstraint_sql(
@@ -2774,6 +2777,17 @@ def build_timetostr_or_tochar(
     return exp.ToChar.from_arg_list(args)
 
 
+def array_sort_order(expression: exp.ArraySort) -> tuple[bool, bool | None] | None:
+    """Whether an ArraySort is ascending and puts NULLs first, or None if either isn't a literal."""
+    asc = expression.args.get("asc") or exp.true()
+    nulls_first = expression.args.get("nulls_first")
+    if not isinstance(asc, exp.Boolean):
+        return None
+    if nulls_first is None:
+        return asc.this, None
+    return (asc.this, nulls_first.this) if isinstance(nulls_first, exp.Boolean) else None
+
+
 def build_replace_with_optional_replacement(args: BuilderArgs) -> exp.Replace:
     return exp.Replace(
         this=seq_get(args, 0),

{sqlglot-30.23.0 → sqlglot-30.24.0}/sqlglot/dialects/oracle.py

@@ -37,6 +37,7 @@ class Oracle(Dialect):
         "HH12": "%I",  # alias for HH
         "HH24": "%H",  # Hour of day (0-23)
         "IW": "%V",  # Calendar week of year (1-52 or 1-53), as defined by the ISO 8601 standard
+        "IYYY": "%G",  # 4-digit year of the ISO 8601 week-numbering calendar
         "MI": "%M",  # Minute (0-59)
         "MM": "%m",  # Month (01-12; January = 01)
         "MON": "%b",  # Abbreviated name of month

{sqlglot-30.23.0 → sqlglot-30.24.0}/sqlglot/dialects/postgres.py

@@ -44,6 +44,10 @@ class Postgres(Dialect):
         "FMSS": "%-S",  # Second
         "HH12": "%I",  # 09
         "HH24": "%H",  # 09
+        "iw": "%V",  # ISO 8601 week of year
+        "IW": "%V",  # ISO 8601 week of year
+        "iyyy": "%G",  # ISO 8601 week-numbering year
+        "IYYY": "%G",  # ISO 8601 week-numbering year
         "mi": "%M",  # zero padded minute
         "MI": "%M",  # zero padded minute
         "mm": "%m",  # 01

{sqlglot-30.23.0 → sqlglot-30.24.0}/sqlglot/dialects/starrocks.py

@@ -18,16 +18,33 @@ class StarRocks(MySQL):
     }
 
     class Tokenizer(MySQL.Tokenizer):
+        # Unlike MySQL, "#" doesn't start a comment
+        COMMENTS = ["--", ("/*", "*/")]
         DASH_COMMENT_REQUIRES_BOUNDARY = False
         COMMENTS_TERMINATE_AT_NEWLINE_ONLY = False
 
         KEYWORDS = {
             **MySQL.Tokenizer.KEYWORDS,
+            "ADMIN": TokenType.COMMAND,
+            "BACKUP": TokenType.COMMAND,
+            "CANCEL": TokenType.COMMAND,
+            "DEALLOCATE": TokenType.COMMAND,
+            "EXPORT": TokenType.COMMAND,
             "HLL": TokenType.HLLSKETCH,
+            "INSTALL": TokenType.COMMAND,
             "LARGEINT": TokenType.INT128,
+            "PAUSE": TokenType.COMMAND,
+            "RECOVER": TokenType.COMMAND,
             "REFRESH": TokenType.REFRESH,
+            "RESTORE": TokenType.COMMAND,
+            "RESUME": TokenType.COMMAND,
+            "STOP": TokenType.COMMAND,
+            "SUBMIT": TokenType.COMMAND,
+            "UNINSTALL": TokenType.COMMAND,
         }
         KEYWORDS.pop("IGNORE")
+        KEYWORDS.pop("#>")
+        KEYWORDS.pop("#>>")
 
     Parser = StarRocksParser
 

{sqlglot-30.23.0 → sqlglot-30.24.0}/sqlglot/expressions/array.py

@@ -98,17 +98,13 @@ class ArraySlice(Expression, Func):
 
 
 class ArraySort(Expression, Func):
-    arg_types = {"this": True, "expression": False}
+    arg_types = {"this": True, "expression": False, "asc": False, "nulls_first": False}
 
 
 class Shuffle(Expression, Func):
     pass
 
 
-class SortArray(Expression, Func):
-    arg_types = {"this": True, "asc": False, "nulls_first": False}
-
-
 # Array predicates / search
 
 

{sqlglot-30.23.0 → sqlglot-30.24.0}/sqlglot/expressions/query.py

@@ -1938,6 +1938,10 @@ class WindowSpec(Expression):
     }
 
 
+class PartitionByExcluding(Expression):
+    arg_types = {"expressions": True}
+
+
 class PreWhere(Expression):
     pass
 
@@ -2020,6 +2024,10 @@ class DropPartition(Expression):
     arg_types = {"expressions": True, "exists": False}
 
 
+class ReplaceColumns(Expression):
+    arg_types = {"expressions": True}
+
+
 class ReplacePartition(Expression):
     arg_types = {"expression": True, "source": True}
 

{sqlglot-30.23.0 → sqlglot-30.24.0}/sqlglot/generator.py

@@ -2178,6 +2178,7 @@ class Generator:
         property_name = exp.Properties.PROPERTY_TO_NAME.get(property_cls)
         if not property_name:
             self.unsupported(f"Unsupported property {expression.key}")
+            return ""
 
         return f"{property_name}={self.sql(expression, 'this')}"
 
@@ -2319,6 +2320,10 @@ class Generator:
         override = " OVERRIDE" if expression.args.get("override") else ""
         return f"LOCKING {kind}{this}{for_or_in} {lock_type}{override}"
 
+    def lockingstatement_sql(self, expression: exp.LockingStatement) -> str:
+        self.unsupported("LOCKING request modifier is not supported")
+        return self.sql(expression, "expression")
+
     def withdataproperty_sql(self, expression: exp.WithDataProperty) -> str:
         data_sql = f"WITH {'NO ' if expression.args.get('no') else ''}DATA"
         statistics = expression.args.get("statistics")
@@ -2561,6 +2566,10 @@ class Generator:
         expression: exp.TableSample,
         tablesample_keyword: str | None = None,
     ) -> str:
+        if expression.expressions:
+            self.unsupported("Multiple sample sets are not supported")
+            return ""
+
         method = self.sql(expression, "method")
         method = f"{method} " if method and self.TABLESAMPLE_WITH_METHOD else ""
         numerator = self.sql(expression, "bucket_numerator")
@@ -3638,6 +3647,9 @@ class Generator:
         partition = self.expressions(expression, key="partition_by", flat=True)
         return f"PARTITION BY {partition}" if partition else ""
 
+    def partitionbyexcluding_sql(self, expression: exp.PartitionByExcluding) -> str:
+        return f"EXCLUDING {self.expressions(expression, flat=True)}"
+
     def windowspec_sql(self, expression: exp.WindowSpec) -> str:
         kind = self.sql(expression, "kind")
         start = csv(self.sql(expression, "start"), self.sql(expression, "start_side"), sep=" ")
@@ -4517,6 +4529,9 @@ class Generator:
     def addconstraint_sql(self, expression: exp.AddConstraint) -> str:
         return f"ADD {self.expressions(expression, indent=False)}"
 
+    def replacecolumns_sql(self, expression: exp.ReplaceColumns) -> str:
+        return f"REPLACE COLUMNS ({self.expressions(expression, flat=True)})"
+
     def addpartition_sql(self, expression: exp.AddPartition) -> str:
         exists = "IF NOT EXISTS " if expression.args.get("exists") else ""
         location = self.sql(expression, "location")
@@ -4771,14 +4786,22 @@ class Generator:
         sqls: list[str] = []
         stack: list[None | str | exp.Expr] = [expression]
         binary_type = type(expression)
+        is_is = binary_type is exp.Is and op in ("IS", "IS NOT")
+        negate = expression.args.get("negate")
 
         while stack:
             node = stack.pop()
 
-            if type(node) is binary_type:
+            if type(node) is binary_type and (
+                node is expression
+                or (is_is and not isinstance(node.expression, exp.Boolean))
+                or node.args.get("negate") == negate
+            ):
                 op_func = node.args.get("operator")
                 if op_func:
                     op = f"OPERATOR({self.sql(op_func)})"
+                elif is_is:
+                    op = "IS NOT" if node.args.get("negate") else "IS"
 
                 stack.append(node.args.get("expression"))
                 stack.append(f" {self.maybe_comment(op, comments=node.comments)} ")
@@ -6053,6 +6076,13 @@ class Generator:
             exp.TimestampDiff(this=expression.this, expression=start_ts, unit=exp.var("SECONDS"))
         )
 
+    def arraysort_sql(self, expression: exp.ArraySort) -> str:
+        asc = expression.args.get("asc")
+        nulls_first = expression.args.get("nulls_first")
+        if (asc and asc != exp.true()) or (nulls_first and nulls_first != exp.false()):
+            self.unsupported("ARRAY_SORT only sorts ascending with NULLs last")
+        return self.func("ARRAY_SORT", expression.this, expression.expression)
+
     def arraysize_sql(self, expression: exp.ArraySize) -> str:
         dim = expression.expression
 

{sqlglot-30.23.0 → sqlglot-30.24.0}/sqlglot/generators/bigquery.py

@@ -3,10 +3,13 @@ from __future__ import annotations
 import logging
 import re
 import typing as t
+from decimal import Decimal
+from fractions import Fraction
 
 from sqlglot import exp, generator, transforms
 from sqlglot.dialects.dialect import (
     arg_max_or_min_no_count,
+    array_sort_order,
     date_add_interval_sql,
     datestrtodate_sql,
     filter_array_using_unnest,
@@ -176,6 +179,90 @@ def _array_contains_sql(self: BigQueryGenerator, expression: exp.ArrayContains)
     )
 
 
+def _widen_decimal(expression: exp.Expr) -> exp.Expr:
+    # NUMERIC holds at most 29 integer and 9 fractional digits, e.g. DECIMAL(38, 0) needs BIGNUMERIC
+    for node in expression.find_all(exp.DataType):
+        if node.is_type(exp.DType.DECIMAL) and node.expressions:
+            precision, *rest = (param.this for param in node.expressions)
+            scale = rest[0] if rest else exp.Literal.number(0)
+            if precision.is_int and scale.is_int:
+                scale_digits = int(scale.name)
+                if int(precision.name) - scale_digits > 29 or scale_digits > 9:
+                    node.set("this", exp.DType.BIGDECIMAL)
+    return expression
+
+
+def _extract_part(part: str) -> t.Callable[[BigQueryGenerator, exp.Func], str]:
+    return lambda self, e: self.sql(exp.func("EXTRACT", exp.var(part), e.this, copy=False))
+
+
+def _day_of_week_iso_sql(self: BigQueryGenerator, expression: exp.DayOfWeekIso) -> str:
+    # DAYOFWEEK is Sunday=1..Saturday=7, ISO is Monday=1..Sunday=7
+    template: exp.Expr = exp.maybe_parse("(MOD(EXTRACT(DAYOFWEEK FROM :this) + 5, 7) + 1)")
+    return self.sql(exp.replace_placeholders(template, this=expression.this))
+
+
+def _array_agg_fold_sql(
+    self: BigQueryGenerator, expression: exp.ArrayDistinct | exp.ArraySort
+) -> str:
+    distinct = False
+    ignore_nulls = False
+    sort: exp.ArraySort | None = None
+    agg: exp.Expr = expression
+    while isinstance(agg, (exp.ArrayDistinct, exp.ArraySort)) and not agg.expression:
+        if isinstance(agg, exp.ArrayDistinct):
+            distinct = True
+            ignore_nulls |= agg.args.get("check_null") is False
+        elif sort is None:
+            sort = agg
+        agg = agg.this
+
+    order = array_sort_order(sort) if sort else None
+
+    # An ARRAY_AGG with its own ORDER BY or LIMIT can't take another
+    if (
+        not isinstance(agg, exp.ArrayAgg)
+        or isinstance(agg.this, (exp.Order, exp.Limit))
+        or (sort is not None and order is None)
+    ):
+        self.unsupported(
+            f"{expression.sql_name()} is only supported on an ARRAY_AGG without ORDER BY or LIMIT and with a literal order"
+        )
+        return self.func(expression.sql_name(), expression.this, expression.expression)
+
+    value = agg.this
+    if isinstance(value, exp.Distinct):
+        distinct, value = True, value.expressions[0]
+
+    folded: exp.Expr = exp.Distinct(expressions=[value]) if distinct else value
+    if order is not None:
+        asc, nulls_first = order
+        keys = [exp.Ordered(this=value.copy(), desc=not asc or None, nulls_first=asc)]
+
+        # Aggregate ORDER BY only puts NULLs first when ascending, so other placements need a key
+        if not ignore_nulls and nulls_first is not None and nulls_first != asc:
+            if distinct:
+                self.unsupported("ARRAY_AGG(DISTINCT) only puts NULLs first when ascending")
+            else:
+                is_null = value.copy().is_(exp.null())
+                keys.insert(
+                    0,
+                    exp.Ordered(
+                        this=is_null, desc=nulls_first or None, nulls_first=not nulls_first
+                    ),
+                )
+        folded = exp.Order(this=folded, expressions=keys)
+    agg.set("this", folded)
+    if ignore_nulls:
+        # All-NULL input yields [], but an empty input still yields NULL.
+        agg = exp.If(
+            this=exp.Count(this=exp.Star()).eq(0),
+            true=exp.null(),
+            false=exp.func("COALESCE", exp.IgnoreNulls(this=agg), exp.array()),
+        )
+    return self.sql(agg)
+
+
 def _ts_or_ds_add_sql(self: BigQueryGenerator, expression: exp.TsOrDsAdd) -> str:
     return date_add_interval_sql("DATE", "ADD")(self, ts_or_ds_add_cast(expression))
 
@@ -311,6 +398,8 @@ class BigQueryGenerator(generator.Generator):
         exp.ArgMin: arg_max_or_min_no_count("MIN_BY"),
         exp.Array: inline_array_unless_query,
         exp.ArrayContains: _array_contains_sql,
+        exp.ArrayDistinct: _array_agg_fold_sql,
+        exp.ArraySort: _array_agg_fold_sql,
         exp.ArrayFilter: filter_array_using_unnest,
         exp.ArrayRemove: filter_array_using_unnest,
         exp.BitwiseAndAgg: rename_func("BIT_AND"),
@@ -318,7 +407,9 @@ class BigQueryGenerator(generator.Generator):
         exp.BitwiseXorAgg: rename_func("BIT_XOR"),
         exp.BitwiseCount: rename_func("BIT_COUNT"),
         exp.ByteLength: rename_func("BYTE_LENGTH"),
-        exp.Cast: transforms.preprocess([transforms.remove_precision_parameterized_types]),
+        exp.Cast: transforms.preprocess(
+            [_widen_decimal, transforms.remove_precision_parameterized_types]
+        ),
         exp.CollateProperty: lambda self, e: (
             f"DEFAULT COLLATE {self.sql(e, 'this')}"
             if e.args.get("default")
@@ -336,6 +427,10 @@ class BigQueryGenerator(generator.Generator):
         exp.DatetimeAdd: date_add_interval_sql("DATETIME", "ADD"),
         exp.DatetimeSub: date_add_interval_sql("DATETIME", "SUB"),
         exp.DateFromUnixDate: rename_func("DATE_FROM_UNIX_DATE"),
+        exp.Day: _extract_part("DAY"),
+        exp.DayOfMonth: _extract_part("DAY"),
+        exp.DayOfWeekIso: _day_of_week_iso_sql,
+        exp.DayOfYear: _extract_part("DAYOFYEAR"),
         exp.Filter: no_filter_sql,
         exp.FromTimeZone: lambda self, e: self.func(
             "DATETIME", self.func("TIMESTAMP", e.this, e.args.get("zone")), "'UTC'"
@@ -346,6 +441,7 @@ class BigQueryGenerator(generator.Generator):
         ),
         exp.Hex: lambda self, e: self.func("UPPER", self.func("TO_HEX", self.sql(e, "this"))),
         exp.HexString: lambda self, e: self.hexstring_sql(e, binary_function_repr="FROM_HEX"),
+        exp.Hour: _extract_part("HOUR"),
         exp.If: if_sql(false_value="NULL"),
         exp.ILike: no_ilike_sql,
         exp.IntDiv: rename_func("DIV"),
@@ -366,12 +462,14 @@ class BigQueryGenerator(generator.Generator):
         exp.MD5: lambda self, e: self.func("TO_HEX", self.func("MD5", e.this)),
         exp.MD5Digest: rename_func("MD5"),
         exp.Min: min_or_least,
+        exp.Month: _extract_part("MONTH"),
         exp.Normalize: lambda self, e: self.func(
             "NORMALIZE_AND_CASEFOLD" if e.args.get("is_casefold") else "NORMALIZE",
             e.this,
             e.args.get("form"),
         ),
         exp.PartitionedByProperty: lambda self, e: f"PARTITION BY {self.sql(e, 'this')}",
+        exp.Quarter: _extract_part("QUARTER"),
         exp.RegexpExtract: lambda self, e: self.func(
             "REGEXP_EXTRACT",
             e.this,
@@ -431,6 +529,8 @@ class BigQueryGenerator(generator.Generator):
         exp.Uuid: lambda *_: "GENERATE_UUID()",
         exp.Values: _derived_table_values_to_unnest,
         exp.VariancePop: rename_func("VAR_POP"),
+        exp.WeekOfYear: _extract_part("ISOWEEK"),
+        exp.Year: _extract_part("YEAR"),
         exp.SafeDivide: rename_func("SAFE_DIVIDE"),
     }
 
@@ -582,6 +682,47 @@ class BigQueryGenerator(generator.Generator):
         "within",
     }
 
+    def frombase_sql(self, expression: exp.FromBase) -> str:
+        # Hex is the only base BigQuery can cast from, and the sign goes before the prefix, e.g. -0xff
+        if expression.expression.name != "16":
+            self.unsupported("FROM_BASE is only supported for base 16")
+            return self.function_fallback_sql(expression)
+
+        prefixed = exp.func(
+            "REGEXP_REPLACE",
+            expression.this,
+            exp.Literal.string("^([+-]?)"),
+            exp.Literal.string("\\10x"),
+            copy=False,
+        )
+        return self.sql(exp.cast(prefixed, exp.DType.BIGINT, copy=False))
+
+    def approxquantile_sql(self, expression: exp.ApproxQuantile) -> str:
+        node: exp.Expr = expression
+        while node.parent and not isinstance(node.parent, (exp.Window, exp.AggFunc, exp.Select)):
+            node = node.parent
+        if isinstance(node.parent, exp.Window) and node.arg_key == "this":
+            self.unsupported("APPROX_QUANTILES does not support window functions")
+            return self.function_fallback_sql(expression)
+
+        # The k/n quantile is APPROX_QUANTILES(x, n)[k], e.g. 0.95 -> n = 20, k = 19. n is at most
+        # 100,000, so the quantile has at most 5 decimal places, and Decimal comparisons are exact
+        quantile = expression.args["quantile"]
+        weight = expression.args.get("weight")
+        value = Decimal(quantile.to_py()) if quantile.is_number else None
+        if (
+            value is None
+            or not 0 <= value <= 1
+            or round(value, 5) != value
+            or (weight and (not weight.is_number or weight.to_py() != 1))
+        ):
+            self.unsupported("APPROX_QUANTILE needs a literal quantile and no weight")
+            return self.function_fallback_sql(expression)
+
+        fraction = Fraction(value)
+        quantiles = exp.func("APPROX_QUANTILES", expression.this, fraction.denominator, copy=False)
+        return self.sql(quantiles[fraction.numerator])
+
     def weekstart_sql(self, expression: exp.WeekStart) -> str:
         if expression.this.name.upper() == "SUNDAY":
             # BigQuery specific optimization since WEEK(SUNDAY) == WEEK

{sqlglot-30.23.0 → sqlglot-30.24.0}/sqlglot/generators/clickhouse.py

@@ -688,7 +688,8 @@ class ClickHouseGenerator(generator.Generator):
             comment_prop = expression.find(exp.SchemaCommentProperty)
             if comment_prop:
                 comment_prop.pop()
-                query.replace(exp.paren(query))
+                if not isinstance(query, exp.Subquery):
+                    query.replace(exp.paren(query))
         else:
             comment_prop = None