sqlglot 30.14.0__tar.gz → 30.16.0__tar.gz

{sqlglot-30.14.0 → sqlglot-30.16.0}/.gitignore

@@ -148,3 +148,9 @@ sqlglot/_version.py
 
 # UV lock file
 uv.lock
+
+# pi (dev. assistant / worktrees)
+.worktrees/
+.pi/
+.pi-subagents/
+.pi-loop.json.lock

{sqlglot-30.14.0 → sqlglot-30.16.0}/CHANGELOG.md

@@ -1,6 +1,113 @@
 Changelog
 =========
 
+## [v30.14.0] - 2026-07-27
+### :boom: BREAKING CHANGES
+- due to [`a715f9f`](https://github.com/tobymao/sqlglot/commit/a715f9f9aa1ba640f558c7602af9a63fc35d8697) - type annotation for databricks NANVL, SIGN, SHIFTLEFT, SIGNUM, SHUFFLE *(PR [#7896](https://github.com/tobymao/sqlglot/pull/7896) by [@fivetran-amrutabhimsenayachit](https://github.com/fivetran-amrutabhimsenayachit))*:
+
+  type annotation for databricks NANVL, SIGN, SHIFTLEFT, SIGNUM, SHUFFLE (#7896)
+
+- due to [`acb635a`](https://github.com/tobymao/sqlglot/commit/acb635a9d5a1e2bdcd4d18e44a63830f10583240) - don't normalize quoted derived output aliases in qualify_outputs *(PR [#7921](https://github.com/tobymao/sqlglot/pull/7921) by [@georgesittas](https://github.com/georgesittas))*:
+
+  don't normalize quoted derived output aliases in qualify_outputs (#7921)
+
+- due to [`c090f35`](https://github.com/tobymao/sqlglot/commit/c090f35c8625d5bb1371a1c0c75ba434f4df6b95) - dedupe colliding star expanded aliases *(PR [#7872](https://github.com/tobymao/sqlglot/pull/7872) by [@fivetran-kwoodbeck](https://github.com/fivetran-kwoodbeck))*:
+
+  dedupe colliding star expanded aliases (#7872)
+
+- due to [`1b442c9`](https://github.com/tobymao/sqlglot/commit/1b442c97deafa067733ff0590f7a612e66ae8aed) - handle non-literal star ILIKE patterns and Snowflake backslash escapes *(PR [#7918](https://github.com/tobymao/sqlglot/pull/7918) by [@georgesittas](https://github.com/georgesittas))*:
+
+  handle non-literal star ILIKE patterns and Snowflake backslash escapes (#7918)
+
+- due to [`66316e3`](https://github.com/tobymao/sqlglot/commit/66316e335fd617d2f3ab8c412ae7a87356431c97) - parse single-digit hour/minute/second without padding CLAUDE *(PR [#7925](https://github.com/tobymao/sqlglot/pull/7925) by [@deepyaman](https://github.com/deepyaman))*:
+
+  parse single-digit hour/minute/second without padding CLAUDE (#7925)
+
+- due to [`c75b7b6`](https://github.com/tobymao/sqlglot/commit/c75b7b610e182fedba20758853d227b81bc1cb34) - annotate unhex for duckdb *(PR [#7930](https://github.com/tobymao/sqlglot/pull/7930) by [@vaishnavi-polekar](https://github.com/vaishnavi-polekar))*:
+
+  annotate unhex for duckdb (#7930)
+
+- due to [`88c4b4a`](https://github.com/tobymao/sqlglot/commit/88c4b4a6f0372978f8ec58c872f0a7f26570bfe3) - parse and annotate duckdb FROM_HEX *(PR [#7931](https://github.com/tobymao/sqlglot/pull/7931) by [@geooo109](https://github.com/geooo109))*:
+
+  parse and annotate duckdb FROM_HEX (#7931)
+
+- due to [`a7725f2`](https://github.com/tobymao/sqlglot/commit/a7725f2a1944bc853deddf8acec29a01946615dd) - annotate convert_tz for mysql *(PR [#7932](https://github.com/tobymao/sqlglot/pull/7932) by [@PiyaDaswadkar](https://github.com/PiyaDaswadkar))*:
+
+  annotate convert_tz for mysql (#7932)
+
+- due to [`85e0b7c`](https://github.com/tobymao/sqlglot/commit/85e0b7c89f3009fe4fbde381df30a1931a975fb4) - annotate UTC_DATE for MySQL *(PR [#7935](https://github.com/tobymao/sqlglot/pull/7935) by [@PiyaDaswadkar](https://github.com/PiyaDaswadkar))*:
+
+  annotate UTC_DATE for MySQL (#7935)
+
+- due to [`7fbb14f`](https://github.com/tobymao/sqlglot/commit/7fbb14f804e601598f3b398276e9d07b9a2d6dbc) - annotate utc_time for mysql *(PR [#7936](https://github.com/tobymao/sqlglot/pull/7936) by [@PiyaDaswadkar](https://github.com/PiyaDaswadkar))*:
+
+  annotate utc_time for mysql (#7936)
+
+- due to [`212fe55`](https://github.com/tobymao/sqlglot/commit/212fe552375e5ef8432a5ed0dd107278075922e8) - annotate utc_timestamp for mysql *(PR [#7937](https://github.com/tobymao/sqlglot/pull/7937) by [@PiyaDaswadkar](https://github.com/PiyaDaswadkar))*:
+
+  annotate utc_timestamp for mysql (#7937)
+
+- due to [`166cd4d`](https://github.com/tobymao/sqlglot/commit/166cd4de90e272c89f14eb7d04d2989d75ef6742) - annotate substringindex for mysql *(PR [#7945](https://github.com/tobymao/sqlglot/pull/7945) by [@PiyaDaswadkar](https://github.com/PiyaDaswadkar))*:
+
+  annotate substringindex for mysql (#7945)
+
+- due to [`26078eb`](https://github.com/tobymao/sqlglot/commit/26078eb7ca56645521fe6f9d60da67d7e9f7e82b) - annotate unhex for mysql *(PR [#7944](https://github.com/tobymao/sqlglot/pull/7944) by [@PiyaDaswadkar](https://github.com/PiyaDaswadkar))*:
+
+  annotate unhex for mysql (#7944)
+
+- due to [`33de21f`](https://github.com/tobymao/sqlglot/commit/33de21fc21cdc05755a2de39318b292c10ccec0f) - annotate regexpsubstr for mysql *(PR [#7946](https://github.com/tobymao/sqlglot/pull/7946) by [@PiyaDaswadkar](https://github.com/PiyaDaswadkar))*:
+
+  annotate regexpsubstr for mysql (#7946)
+
+- due to [`2aae7f7`](https://github.com/tobymao/sqlglot/commit/2aae7f7605ed38fe0950d004cb9defc1dd9621e5) - preserve x IS NOT NULL instead of normalizing to NOT x IS NULL *(PR [#7938](https://github.com/tobymao/sqlglot/pull/7938) by [@geooo109](https://github.com/geooo109))*:
+
+  preserve x IS NOT NULL instead of normalizing to NOT x IS NULL (#7938)
+
+
+### :sparkles: New Features
+- [`c402094`](https://github.com/tobymao/sqlglot/commit/c4020942b711eb0f5c8a182ff580b31541aed07f) - **duckdb**: transpile BigQuery ARRAY_CONCAT_AGG to DuckDB *(PR [#7891](https://github.com/tobymao/sqlglot/pull/7891) by [@sirockin](https://github.com/sirockin))*
+- [`8be76d2`](https://github.com/tobymao/sqlglot/commit/8be76d20a133ee818cffd52e04366fdc74d6a89e) - **duckdb**: convert ARRAY_AGG IGNORE NULLS to FILTER clause *(PR [#7893](https://github.com/tobymao/sqlglot/pull/7893) by [@sirockin](https://github.com/sirockin))*
+- [`a715f9f`](https://github.com/tobymao/sqlglot/commit/a715f9f9aa1ba640f558c7602af9a63fc35d8697) - **optimizer**: type annotation for databricks NANVL, SIGN, SHIFTLEFT, SIGNUM, SHUFFLE *(PR [#7896](https://github.com/tobymao/sqlglot/pull/7896) by [@fivetran-amrutabhimsenayachit](https://github.com/fivetran-amrutabhimsenayachit))*
+- [`ee5a989`](https://github.com/tobymao/sqlglot/commit/ee5a989cd5b756c10068837887f34ffe8606ce7f) - **mysql**: support INSERT ... SET ... syntax closes [#7927](https://github.com/tobymao/sqlglot/pull/7927) *(PR [#7929](https://github.com/tobymao/sqlglot/pull/7929) by [@georgesittas](https://github.com/georgesittas))*
+  - :arrow_lower_right: *addresses issue [#7927](https://github.com/tobymao/sqlglot/issues/7927) opened by [@samerdokas](https://github.com/samerdokas)*
+- [`c75b7b6`](https://github.com/tobymao/sqlglot/commit/c75b7b610e182fedba20758853d227b81bc1cb34) - **optimizer**: annotate unhex for duckdb *(PR [#7930](https://github.com/tobymao/sqlglot/pull/7930) by [@vaishnavi-polekar](https://github.com/vaishnavi-polekar))*
+- [`88c4b4a`](https://github.com/tobymao/sqlglot/commit/88c4b4a6f0372978f8ec58c872f0a7f26570bfe3) - **optimizer**: parse and annotate duckdb FROM_HEX *(PR [#7931](https://github.com/tobymao/sqlglot/pull/7931) by [@geooo109](https://github.com/geooo109))*
+- [`3cd3e58`](https://github.com/tobymao/sqlglot/commit/3cd3e58e10dcdf941f14765889641a5974e550ae) - **duckdb**: transpile BigQuery IN UNNEST(array) to ARRAY_CONTAINS *(PR [#7892](https://github.com/tobymao/sqlglot/pull/7892) by [@sirockin](https://github.com/sirockin))*
+- [`a7725f2`](https://github.com/tobymao/sqlglot/commit/a7725f2a1944bc853deddf8acec29a01946615dd) - **optimizer**: annotate convert_tz for mysql *(PR [#7932](https://github.com/tobymao/sqlglot/pull/7932) by [@PiyaDaswadkar](https://github.com/PiyaDaswadkar))*
+- [`85e0b7c`](https://github.com/tobymao/sqlglot/commit/85e0b7c89f3009fe4fbde381df30a1931a975fb4) - **optimizer**: annotate UTC_DATE for MySQL *(PR [#7935](https://github.com/tobymao/sqlglot/pull/7935) by [@PiyaDaswadkar](https://github.com/PiyaDaswadkar))*
+- [`7fbb14f`](https://github.com/tobymao/sqlglot/commit/7fbb14f804e601598f3b398276e9d07b9a2d6dbc) - **optimizer**: annotate utc_time for mysql *(PR [#7936](https://github.com/tobymao/sqlglot/pull/7936) by [@PiyaDaswadkar](https://github.com/PiyaDaswadkar))*
+- [`212fe55`](https://github.com/tobymao/sqlglot/commit/212fe552375e5ef8432a5ed0dd107278075922e8) - **optimizer**: annotate utc_timestamp for mysql *(PR [#7937](https://github.com/tobymao/sqlglot/pull/7937) by [@PiyaDaswadkar](https://github.com/PiyaDaswadkar))*
+- [`6bb78c9`](https://github.com/tobymao/sqlglot/commit/6bb78c9aa8982b1c69378f797f02c8f248af97b4) - **snowflake**: add support for input => select ... kwarg syntax *(commit by [@georgesittas](https://github.com/georgesittas))*
+- [`166cd4d`](https://github.com/tobymao/sqlglot/commit/166cd4de90e272c89f14eb7d04d2989d75ef6742) - **optimizer**: annotate substringindex for mysql *(PR [#7945](https://github.com/tobymao/sqlglot/pull/7945) by [@PiyaDaswadkar](https://github.com/PiyaDaswadkar))*
+- [`26078eb`](https://github.com/tobymao/sqlglot/commit/26078eb7ca56645521fe6f9d60da67d7e9f7e82b) - **optimizer**: annotate unhex for mysql *(PR [#7944](https://github.com/tobymao/sqlglot/pull/7944) by [@PiyaDaswadkar](https://github.com/PiyaDaswadkar))*
+- [`33de21f`](https://github.com/tobymao/sqlglot/commit/33de21fc21cdc05755a2de39318b292c10ccec0f) - **optimizer**: annotate regexpsubstr for mysql *(PR [#7946](https://github.com/tobymao/sqlglot/pull/7946) by [@PiyaDaswadkar](https://github.com/PiyaDaswadkar))*
+- [`2aae7f7`](https://github.com/tobymao/sqlglot/commit/2aae7f7605ed38fe0950d004cb9defc1dd9621e5) - **postgres**: preserve x IS NOT NULL instead of normalizing to NOT x IS NULL *(PR [#7938](https://github.com/tobymao/sqlglot/pull/7938) by [@geooo109](https://github.com/geooo109))*
+  - :arrow_lower_right: *addresses issue [#7909](https://github.com/tobymao/sqlglot/issues/7909) opened by [@tonywasson](https://github.com/tonywasson)*
+
+### :bug: Bug Fixes
+- [`c368c5e`](https://github.com/tobymao/sqlglot/commit/c368c5eb2d84133a18f38ff98946b112c81f060d) - **duckdb**: handle ORDER BY and LIMIT for bq ARRAY_CONCAT_AGG *(PR [#7920](https://github.com/tobymao/sqlglot/pull/7920) by [@geooo109](https://github.com/geooo109))*
+- [`acb635a`](https://github.com/tobymao/sqlglot/commit/acb635a9d5a1e2bdcd4d18e44a63830f10583240) - **optimizer**: don't normalize quoted derived output aliases in qualify_outputs *(PR [#7921](https://github.com/tobymao/sqlglot/pull/7921) by [@georgesittas](https://github.com/georgesittas))*
+  - :arrow_lower_right: *fixes issue [#7919](https://github.com/tobymao/sqlglot/issues/7919) opened by [@baruchoxman](https://github.com/baruchoxman)*
+- [`c090f35`](https://github.com/tobymao/sqlglot/commit/c090f35c8625d5bb1371a1c0c75ba434f4df6b95) - **optimizer**: dedupe colliding star expanded aliases *(PR [#7872](https://github.com/tobymao/sqlglot/pull/7872) by [@fivetran-kwoodbeck](https://github.com/fivetran-kwoodbeck))*
+- [`1b442c9`](https://github.com/tobymao/sqlglot/commit/1b442c97deafa067733ff0590f7a612e66ae8aed) - handle non-literal star ILIKE patterns and Snowflake backslash escapes *(PR [#7918](https://github.com/tobymao/sqlglot/pull/7918) by [@georgesittas](https://github.com/georgesittas))*
+- [`66316e3`](https://github.com/tobymao/sqlglot/commit/66316e335fd617d2f3ab8c412ae7a87356431c97) - **hive**: parse single-digit hour/minute/second without padding CLAUDE *(PR [#7925](https://github.com/tobymao/sqlglot/pull/7925) by [@deepyaman](https://github.com/deepyaman))*
+- [`e265dca`](https://github.com/tobymao/sqlglot/commit/e265dcafd6a28bdfb43a6491777b433b49a1ebd7) - **optimizer**: canonicalize unaliased scalar subquery projections *(PR [#7928](https://github.com/tobymao/sqlglot/pull/7928) by [@fivetran-kwoodbeck](https://github.com/fivetran-kwoodbeck))*
+- [`b0a8635`](https://github.com/tobymao/sqlglot/commit/b0a8635ff3fcd769743c4848651497cce6acee19) - **parser**: treat `TokenType.OUT` as an identifier token *(PR [#7933](https://github.com/tobymao/sqlglot/pull/7933) by [@georgesittas](https://github.com/georgesittas))*
+- [`ba0bff3`](https://github.com/tobymao/sqlglot/commit/ba0bff3d9164217f06cfcf9fadbdfd35ae84eefe) - **jsonpath**: preserve falsey union members *(PR [#7957](https://github.com/tobymao/sqlglot/pull/7957) by [@dev-willbird1936](https://github.com/dev-willbird1936))*
+  - :arrow_lower_right: *fixes issue [#7956](https://github.com/tobymao/sqlglot/issues/7956) opened by [@dev-willbird1936](https://github.com/dev-willbird1936)*
+- [`b9fd4c9`](https://github.com/tobymao/sqlglot/commit/b9fd4c9a5d3e5aa4ccc5dff395cbde3227f18e5a) - **typing**: on_qualify expects a `Table` argument *(commit by [@georgesittas](https://github.com/georgesittas))*
+
+### :zap: Performance Improvements
+- [`1a38c05`](https://github.com/tobymao/sqlglot/commit/1a38c056a1f47cfc07c9bef4ed11b795a91f947e) - **optimizer**: speed up merge_subqueries *(PR [#7924](https://github.com/tobymao/sqlglot/pull/7924) by [@fivetran-kwoodbeck](https://github.com/fivetran-kwoodbeck))*
+- [`b8180fd`](https://github.com/tobymao/sqlglot/commit/b8180fdb8c2617b7e51e1c9491a76cae852eb87b) - **optimizer**: speed up merge_subqueries *(PR [#7924](https://github.com/tobymao/sqlglot/pull/7924) by [@fivetran-kwoodbeck](https://github.com/fivetran-kwoodbeck))*
+
+### :wrench: Chores
+- [`cda0147`](https://github.com/tobymao/sqlglot/commit/cda0147754257779c4c103d617c04d2deb6979b9) - **generator**: refactor ARRAY_AGG tests and bq -> duckdb transpilation *(PR [#7922](https://github.com/tobymao/sqlglot/pull/7922) by [@geooo109](https://github.com/geooo109))*
+- [`f37d1b5`](https://github.com/tobymao/sqlglot/commit/f37d1b5d6305ff293f7b1757ce1253c3299d8e88) - **duckdb**: refactor transpilation of IN UNNEST *(commit by [@geooo109](https://github.com/geooo109))*
+- [`296d8b0`](https://github.com/tobymao/sqlglot/commit/296d8b02e7f7b4d0634194ed367ac3ce49a03714) - polish README file *(PR [#7947](https://github.com/tobymao/sqlglot/pull/7947) by [@georgesittas](https://github.com/georgesittas))*
+- [`29c651b`](https://github.com/tobymao/sqlglot/commit/29c651b85309693924b8c034501e6a2733d14588) - retrigger v30.14.0 release *(commit by [@georgesittas](https://github.com/georgesittas))*
+
+
 ## [v30.13.0] - 2026-07-20
 ### :boom: BREAKING CHANGES
 - due to [`58f5bf9`](https://github.com/tobymao/sqlglot/commit/58f5bf9b40dda34784bcb2d3bf0a04f02490de12) - databricks type annotation for REGEXP_COUNT, REGEXP_EXTRACT_ALL *(PR [#7797](https://github.com/tobymao/sqlglot/pull/7797) by [@fivetran-amrutabhimsenayachit](https://github.com/fivetran-amrutabhimsenayachit))*:
@@ -15078,3 +15185,4 @@ pip install "sqlglot[c]"   # compiled — faster, but no subclassing
 [v30.11.0]: https://github.com/tobymao/sqlglot/compare/v30.10.0...v30.11.0
 [v30.12.0]: https://github.com/tobymao/sqlglot/compare/v30.11.0...v30.12.0
 [v30.13.0]: https://github.com/tobymao/sqlglot/compare/v30.12.0...v30.13.0
+[v30.14.0]: https://github.com/tobymao/sqlglot/compare/v30.13.0...v30.14.0

{sqlglot-30.14.0/sqlglot.egg-info → sqlglot-30.16.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlglot
-Version: 30.14.0
+Version: 30.16.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.14.0; python_version >= "3.10" and extra == "c"
+Requires-Dist: sqlglotc==30.16.0; python_version >= "3.10" and extra == "c"
 Provides-Extra: rs
 Requires-Dist: sqlglotrs==0.13.0; extra == "rs"
-Requires-Dist: sqlglotc==30.14.0; python_version >= "3.10" and extra == "rs"
+Requires-Dist: sqlglotc==30.16.0; python_version >= "3.10" and extra == "rs"
 Dynamic: license-file
 Dynamic: provides-extra
 

{sqlglot-30.14.0 → sqlglot-30.16.0}/sqlglot/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '30.14.0'
-__version_tuple__ = version_tuple = (30, 14, 0)
+__version__ = version = '30.16.0'
+__version_tuple__ = version_tuple = (30, 16, 0)
 
-__commit_id__ = commit_id = 'g29c651b85'
+__commit_id__ = commit_id = 'gbbfb497f1'

sqlglot-30.16.0/sqlglot/anonymize.py

@@ -0,0 +1,307 @@
+from __future__ import annotations
+
+import string
+
+from sqlglot.dialects.dialect import Dialect, DialectType
+from sqlglot.errors import TokenError
+from sqlglot.tokens import Token, TokenType
+
+
+ALPHABET = string.ascii_lowercase
+ALPHABET_SIZE = len(ALPHABET)
+ANONYMIZED_TYPES = {
+    TokenType.BIT_STRING,
+    TokenType.BYTE_STRING,
+    TokenType.HEX_STRING,
+    TokenType.HEREDOC_STRING,
+    TokenType.IDENTIFIER,
+    TokenType.NATIONAL_STRING,
+    TokenType.NUMBER,
+    TokenType.RAW_STRING,
+    TokenType.STRING,
+    TokenType.UNICODE_STRING,
+    TokenType.VAR,
+}
+QUOTED_TYPES = ANONYMIZED_TYPES - {TokenType.NUMBER, TokenType.VAR}
+REWRITTEN_TYPES = {TokenType.HINT, TokenType.UNKNOWN}
+
+
+def anonymize(
+    sql_or_tokens: list[Token] | str,
+    dialect: DialectType = None,
+) -> list[Token]:
+    """Replaces sensitive tokens (identifiers, strings, numbers) with fixed-width,
+    length-preserving, consistent aliases, and blanks out comments and hint bodies. When a
+    SQL string is given, it is tokenized with `dialect` first; any un-tokenized remainder
+    (e.g. an unterminated literal) is appended as a blanked UNKNOWN token. Mutates and
+    returns `sql_or_tokens`.
+
+    Args:
+        sql_or_tokens: The SQL string to anonymize, or its token list.
+        dialect: The dialect used to tokenize a SQL string.
+    """
+    dialect = Dialect.get_or_raise(dialect)
+    tokenizer_class = dialect.tokenizer_class
+    parser_class = dialect.parser_class
+
+    errored = False
+    if isinstance(sql_or_tokens, str):
+        sql = sql_or_tokens
+        tokenizer = dialect.tokenizer()
+        try:
+            tokens = tokenizer.tokenize(sql)
+        except TokenError:
+            tokens = tokenizer.tokens
+            errored = True
+    else:
+        tokens = sql_or_tokens
+        sql = None
+
+    hint_start = tokenizer_class.HINT_START
+    hint_end = tokenizer_class._COMMENTS.get(hint_start)
+    nested = tokenizer_class.NESTED_COMMENTS
+
+    seen: dict[tuple[bool, str], str] = {}
+    counter = 0
+
+    for i, token in enumerate(tokens):
+        token.comments = [_blank(comment) for comment in token.comments]
+
+        if token.token_type == TokenType.HINT:
+            # A hint's text is the whole /*+ ... */ comment, so its body is blanked as well
+            text, stop = _blank_comment(token.text, 0, hint_start, hint_end, nested)
+            token.text = text + _blank(token.text[stop:])
+            continue
+
+        if (
+            token.token_type == TokenType.VAR
+            and i + 1 < len(tokens)
+            and tokens[i + 1].token_type == TokenType.L_PAREN
+        ):
+            # A function name can live in either registry, e.g. JSON_OBJECT is only in
+            # FUNCTION_PARSERS. They're consulted separately to avoid building their union
+            name = token.text.upper()
+            if name in parser_class.FUNCTIONS or name in parser_class.FUNCTION_PARSERS:
+                continue
+        if token.token_type not in ANONYMIZED_TYPES:
+            continue
+        if not token.text:
+            continue
+
+        is_number = token.token_type == TokenType.NUMBER
+        key = (is_number, token.text)
+        alias = seen.get(key)
+        if alias is None:
+            seen[key] = (
+                _number_alias(counter, token.text) if is_number else _alias(counter, token.text)
+            )
+            counter += 1
+        token.text = seen[key]
+
+    if sql is not None and errored:
+        start = tokens[-1].end + 1 if tokens else 0
+        length = len(sql)
+        while start < length and sql[start].isspace():
+            start += 1
+        if start < length:
+            # The first two characters are kept so that the delimiter the tokenizer choked
+            # on is still visible, e.g. 'u, /*, $$, `u
+            tokens.append(
+                Token(
+                    TokenType.UNKNOWN,
+                    sql[start : start + 2] + "." * (length - start - 2),
+                    start=start,
+                    end=length - 1,
+                    line=sql.count("\n", 0, start) + 1,
+                    col=start - sql.rfind("\n", 0, start),
+                )
+            )
+
+    return tokens
+
+
+def render(sql: str, tokens: list[Token], dialect: DialectType = None) -> str:
+    """Recreates the (anonymized) SQL string from the original `sql` and token positions.
+
+    Every token is rendered over its own source span, so the result is always as long as
+    `sql`: a token that wasn't anonymized is emitted verbatim, keeping the spelling the
+    tokenizer normalized away, and an anonymized one has its alias fitted between the
+    quotes of its span. The gaps between tokens hold only whitespace and comments, so
+    they're redacted rather than reconstructed: comment markers and whitespace survive,
+    everything else is blanked. That covers anything the tokenizer didn't reach as well,
+    which is a trailing gap whenever `anonymize` wasn't the one to tokenize `sql`.
+
+    Args:
+        sql: The original SQL string.
+        tokens: The anonymized tokens to render.
+        dialect: The dialect used to identify comments and quotes in `sql`.
+    """
+    tokenizer_class = Dialect.get_or_raise(dialect).tokenizer_class
+    comments = sorted(tokenizer_class._COMMENTS.items(), key=lambda c: len(c[0]), reverse=True)
+    nested = tokenizer_class.NESTED_COMMENTS
+    quotes = sorted(
+        {
+            **tokenizer_class._QUOTES,
+            **{start: end for start, (end, _) in tokenizer_class._FORMAT_STRINGS.items()},
+            **tokenizer_class._IDENTIFIERS,
+        }.items(),
+        key=lambda quote: (len(quote[0]), len(quote[1])),
+        reverse=True,
+    )
+
+    result = []
+    prev = 0
+
+    for token in tokens:
+        result.append(_redact(sql[prev : token.start], comments, nested))
+        prev = token.end + 1
+        span = sql[token.start : prev]
+        if token.token_type in REWRITTEN_TYPES:
+            # Blanked in place by `anonymize`, or synthesized by it, so already span-shaped
+            result.append(token.text)
+        elif token.token_type in ANONYMIZED_TYPES:
+            result.append(_fit(span, token.text, quotes, token.token_type))
+        else:
+            result.append(span)
+
+    result.append(_redact(sql[prev:], comments, nested))
+
+    return "".join(result)
+
+
+def _alias(counter: int, text: str) -> str:
+    digits = []
+    while counter:
+        counter, digit = divmod(counter, ALPHABET_SIZE)
+        digits.append(ALPHABET[digit])
+
+    letters = "".join(reversed(digits)).rjust(sum(not char.isspace() for char in text), "a")
+
+    alias = []
+    i = 0
+    for char in text:
+        if char.isspace():
+            alias.append(char)
+        else:
+            alias.append(letters[i])
+            i += 1
+
+    return "".join(alias)
+
+
+def _number_alias(counter: int, text: str) -> str:
+    if len(text) > 4000:
+        digits_seen = False
+        blanked = []
+        for char in text:
+            if char.isdigit():
+                blanked.append("0" if digits_seen else "1")
+                digits_seen = True
+            else:
+                blanked.append(char)
+        return "".join(blanked)
+
+    sep = "e" if "e" in text else ("E" if "E" in text else "")
+    mantissa, _, exponent = text.partition(sep) if sep else (text, "", "")
+    sign = ""
+    if exponent.startswith(("-", "+")):
+        sign, exponent = exponent[0], exponent[1:]
+    exponent_length = len(exponent)
+
+    integer, dot, fraction = mantissa.partition(".")
+    integer_length = len(integer)
+    digits = integer_length + len(fraction)
+    mantissa_value = 10 ** (digits - 1) + counter % (9 * 10 ** (digits - 1))
+    result = str(mantissa_value)
+    if dot:
+        result = result[:integer_length] + "." + result[integer_length:]
+    if sep:
+        # The exponent marker is kept even when there are no digits after it, e.g. 1e
+        result += sep + sign
+        if exponent_length:
+            exponent_value = 10 ** (exponent_length - 1) + (counter // (9 * 10 ** (digits - 1))) % (
+                9 * 10 ** (exponent_length - 1)
+            )
+            result += str(exponent_value)
+
+    return result
+
+
+def _fit(span: str, alias: str, quotes: list[tuple[str, str]], token_type: TokenType) -> str:
+    """Fits `alias` into the quoted region of `span`, so the two are always the same length."""
+    start = end = 0
+
+    if token_type in QUOTED_TYPES:
+        for open_quote, close_quote in quotes:
+            if (
+                len(span) >= len(open_quote) + len(close_quote)
+                and span.startswith(open_quote)
+                and span.endswith(close_quote)
+            ):
+                start, end = len(open_quote), len(close_quote)
+
+                if token_type == TokenType.HEREDOC_STRING:
+                    # A heredoc's tag is part of its delimiter, e.g. $tag$body$tag$
+                    open_end = span.find(close_quote, start)
+                    close_start = span.rfind(open_quote, 0, len(span) - end)
+                    if start <= open_end < close_start:
+                        start, end = open_end + len(close_quote), len(span) - close_start
+
+                break
+
+    width = len(span) - start - end
+    pad = "0" if token_type == TokenType.NUMBER else "a"
+
+    return span[:start] + alias[:width].rjust(width, pad) + span[len(span) - end :]
+
+
+def _blank(sql: str) -> str:
+    return "".join(char if char.isspace() else "." for char in sql)
+
+
+def _blank_comment(sql: str, i: int, start: str, end: str | None, nested: bool) -> tuple[str, int]:
+    """Blanks the body of the comment at `i`, returning its text and the index past it."""
+    body = i + len(start)
+
+    if not end:
+        stop = sql.find("\n", body)
+        stop = len(sql) if stop == -1 else stop
+        return start + _blank(sql[body:stop]), stop
+
+    depth = 1
+    j = body
+    while j < len(sql):
+        if nested and sql.startswith(start, j):
+            depth += 1
+            j += len(start)
+        elif sql.startswith(end, j):
+            j += len(end)
+            depth -= 1
+            if not depth:
+                return start + _blank(sql[body : j - len(end)]) + end, j
+        else:
+            j += 1
+
+    return start + _blank(sql[body:]), len(sql)
+
+
+def _redact(sql: str, comments: list[tuple[str, str | None]], nested: bool) -> str:
+    if not sql or sql.isspace():
+        return sql
+
+    result = []
+    i = 0
+    length = len(sql)
+
+    while i < length:
+        for start, end in comments:
+            if sql.startswith(start, i):
+                text, i = _blank_comment(sql, i, start, end, nested)
+                result.append(text)
+                break
+        else:
+            char = sql[i]
+            result.append(char if char.isspace() else ".")
+            i += 1
+
+    return "".join(result)

{sqlglot-30.14.0 → sqlglot-30.16.0}/sqlglot/dialects/bigquery.py

@@ -193,11 +193,8 @@ class BigQuery(Dialect):
             "EXCEPTION": TokenType.COMMAND,
             "EXPORT": TokenType.EXPORT,
             "FLOAT64": TokenType.DOUBLE,
-            "FOR SYSTEM TIME": TokenType.TIMESTAMP_SNAPSHOT,
-            "FOR SYSTEM_TIME": TokenType.TIMESTAMP_SNAPSHOT,
             "LOOP": TokenType.COMMAND,
             "MODEL": TokenType.MODEL,
-            "NOT DETERMINISTIC": TokenType.VOLATILE,
             "RECORD": TokenType.STRUCT,
             "REPEAT": TokenType.COMMAND,
             "TIMESTAMP": TokenType.TIMESTAMPTZ,

{sqlglot-30.14.0 → sqlglot-30.16.0}/sqlglot/dialects/clickhouse.py

@@ -17,7 +17,6 @@ class ClickHouse(Dialect):
     NORMALIZE_FUNCTIONS: bool | str = False
     NULL_ORDERING = "nulls_are_last"
     SUPPORTS_USER_DEFINED_TYPES = False
-    SAFE_DIVISION = True
     LOG_BASE_FIRST: bool | None = None
     FORCE_EARLY_ALIAS_REF_EXPANSION = True
     PRESERVE_ORIGINAL_NAMES = True

{sqlglot-30.14.0 → sqlglot-30.16.0}/sqlglot/dialects/dialect.py

@@ -24,6 +24,7 @@ from sqlglot.helper import (
     ensure_list,
 )
 from sqlglot.jsonpath import ALL_JSON_PATH_PARTS, JSONPathTokenizer, parse as parse_json_path
+from sqlglot.optimizer.scope import find_all_in_scope
 from sqlglot.parser import Parser
 from sqlglot.parsers.base import BaseParser
 from sqlglot.time import TIMEZONES, format_time, subsecond_precision
@@ -1700,7 +1701,7 @@ def timestamptrunc_sql(
     func: str = "DATE_TRUNC", zone: bool = False
 ) -> t.Callable[[Generator, exp.TimestampTrunc], str]:
     def _timestamptrunc_sql(self: Generator, expression: exp.TimestampTrunc) -> str:
-        args = [unit_to_str(expression), expression.this]
+        args = [weekstart_unit_to_str(self, expression), expression.this]
         if zone:
             args.append(expression.args.get("zone"))
         return self.func(func, *args)
@@ -1993,6 +1994,23 @@ def ts_or_ds_add_cast(expression: exp.TsOrDsAdd) -> exp.TsOrDsAdd:
     return expression
 
 
+def remove_ts_or_ds_to_date(
+    to_sql: t.Callable[[Generator, exp.Expr], str] | None = None,
+    args: tuple[str, ...] = ("this",),
+) -> t.Callable[[Generator, exp.Func], str]:
+    def func(self: Generator, expression: exp.Func) -> str:
+        for arg_key in args:
+            arg = expression.args.get(arg_key)
+            if isinstance(arg, (exp.TsOrDsToDate, exp.TsOrDsToTimestamp)) and not arg.args.get(
+                "format"
+            ):
+                expression.set(arg_key, arg.this)
+
+        return to_sql(self, expression) if to_sql else self.function_fallback_sql(expression)
+
+    return func
+
+
 def date_delta_sql(name: str, cast: bool = False) -> t.Callable[[Generator, DATE_ADD_OR_DIFF], str]:
     def _delta_sql(self: Generator, expression: DATE_ADD_OR_DIFF) -> str:
         if cast and isinstance(expression, exp.TsOrDsAdd):
@@ -2043,12 +2061,28 @@ def unit_to_str(expression: exp.Expr, default: str = "DAY") -> exp.Expr | None:
     if not unit:
         return exp.Literal.string(default) if default else None
 
+    if isinstance(unit, exp.WeekStart):
+        # WEEK(<day>) is BigQuery-only syntax, so it degrades to the plain WEEK unit. Unlike
+        # Generator.weekstart_name, this can't warn about a changed week start (no generator
+        # access here) - callers that need the warning should use weekstart_unit_to_str
+        return exp.Literal.string("WEEK")
+
     if isinstance(unit, exp.Placeholder) or type(unit) not in (exp.Var, exp.Literal):
         return unit
 
     return exp.Literal.string(unit.name)
 
 
+def weekstart_unit_to_str(
+    self: Generator, expression: exp.Expr, default: str = "DAY"
+) -> exp.Expr | None:
+    unit = expression.args.get("unit")
+    if isinstance(unit, exp.WeekStart):
+        return exp.Literal.string(self.weekstart_name(unit))
+
+    return unit_to_str(expression, default)
+
+
 def unit_to_var(expression: exp.Expr, default: str = "DAY") -> exp.Expr | None:
     unit = expression.args.get("unit")
 
@@ -2072,10 +2106,14 @@ WEEK_START_DAY_TO_DOW = {
 }
 
 
+def week_offset_to_dow(offset: int) -> int:
+    """Convert a dialect's WEEK_OFFSET (days relative to Monday) to the ISO day number of its week start."""
+    return offset % 7 + 1
+
+
 def week_unit_to_dow(unit: exp.Expr | None) -> int | None:
     """
-    Compute the week start day for a week-ish diff unit, e.g BigQuery's WEEK(<day>)
-    or ISOWEEK unit parts.
+    Compute the week start day for a week-ish diff unit, e.g BigQuery's WEEK(<day>) or ISOWEEK unit parts.
 
     Args:
         unit: The unit expression (Var for WEEK/ISOWEEK or WeekStart)
@@ -2147,7 +2185,7 @@ def merge_without_target_sql(self: Generator, expression: exp.Merge) -> str:
         then: exp.Insert | exp.Update | None = when.args.get("then")
         if then:
             if isinstance(then, exp.Update):
-                for equals in then.find_all(exp.EQ):
+                for equals in find_all_in_scope(then, exp.EQ):
                     equal_lhs = equals.this
                     if (
                         isinstance(equal_lhs, exp.Column)
@@ -2175,7 +2213,11 @@ def build_json_extract_path(
         for arg in args[1:]:
             if not isinstance(arg, exp.Literal):
                 # We use the fallback parser because we can't really transpile non-literals safely
-                return expr_type.from_arg_list(args)
+                return expr_type(
+                    this=seq_get(args, 0),
+                    expression=seq_get(args, 1),
+                    expressions=list(args[2:]) or None,
+                )
 
             text = arg.name
             if is_int(text) and (not arrow_req_json_type or not arg.is_string):

{sqlglot-30.14.0 → sqlglot-30.16.0}/sqlglot/dialects/dremio.py

@@ -67,12 +67,6 @@ class Dremio(Dialect):
     class Tokenizer(tokens.Tokenizer):
         COMMENTS = ["--", "//", ("/*", "*/")]
 
-        KEYWORDS = {
-            **tokens.Tokenizer.KEYWORDS,
-            "AT SNAPSHOT": tokens.TokenType.VERSION_SNAPSHOT,
-            "AT TIMESTAMP": tokens.TokenType.TIMESTAMP_SNAPSHOT,
-        }
-
     Parser = DremioParser
 
     Generator = DremioGenerator

{sqlglot-30.14.0 → sqlglot-30.16.0}/sqlglot/dialects/duckdb.py

@@ -16,7 +16,6 @@ from sqlglot.typing.duckdb import EXPRESSION_METADATA
 class DuckDB(Dialect):
     NULL_ORDERING = "nulls_are_last"
     SUPPORTS_USER_DEFINED_TYPES = True
-    SAFE_DIVISION = True
     INDEX_OFFSET = 1
     CONCAT_COALESCE = True
     CONCAT_WS_COALESCE = True

{sqlglot-30.14.0 → sqlglot-30.16.0}/sqlglot/dialects/hive.py

@@ -109,8 +109,6 @@ class Hive(Dialect):
             "MINUS": TokenType.EXCEPT,
             "MSCK REPAIR": TokenType.COMMAND,
             "REFRESH": TokenType.REFRESH,
-            "TIMESTAMP AS OF": TokenType.TIMESTAMP_SNAPSHOT,
-            "VERSION AS OF": TokenType.VERSION_SNAPSHOT,
             "SERDEPROPERTIES": TokenType.SERDE_PROPERTIES,
         }
 

{sqlglot-30.14.0 → sqlglot-30.16.0}/sqlglot/dialects/mysql.py

@@ -96,7 +96,6 @@ class MySQL(Dialect):
             "SERIAL": TokenType.SERIAL,
             "SIGNED": TokenType.BIGINT,
             "SIGNED INTEGER": TokenType.BIGINT,
-            "SOUNDS LIKE": TokenType.SOUNDS_LIKE,
             "START": TokenType.BEGIN,
             "TIMESTAMP": TokenType.TIMESTAMPTZ,
             "TINYBLOB": TokenType.TINYBLOB,

{sqlglot-30.14.0 → sqlglot-30.16.0}/sqlglot/dialects/starrocks.py

@@ -14,6 +14,7 @@ class StarRocks(MySQL):
         KEYWORDS = {
             **MySQL.Tokenizer.KEYWORDS,
             "LARGEINT": TokenType.INT128,
+            "REFRESH": TokenType.REFRESH,
         }
 
     Parser = StarRocksParser