sqlglot 30.4.2__tar.gz → 30.5.0__tar.gz

{sqlglot-30.4.2 → sqlglot-30.5.0}/CHANGELOG.md

@@ -1,6 +1,16 @@
 Changelog
 =========
 
+## [v30.4.3] - 2026-04-13
+### :bug: Bug Fixes
+- [`713e95f`](https://github.com/tobymao/sqlglot/commit/713e95fb9bca5fa6ac0aa660f599a4be632872e2) - **snowflake**: parse GET_DDL #unknown_policy in ROW ACCESS POLICY [CLAUDE] *(PR [#7491](https://github.com/tobymao/sqlglot/pull/7491) by [@eakmanrq](https://github.com/eakmanrq))*
+
+
+## [v30.4.2] - 2026-04-08
+### :bug: Bug Fixes
+- [`d04595e`](https://github.com/tobymao/sqlglot/commit/d04595e1ba91a778e4b76f3f84dcb41649594e32) - incomplete `ColumnMapping` type hint *(commit by [@georgesittas](https://github.com/georgesittas))*
+
+
 ## [v30.4.0] - 2026-04-08
 ### :sparkles: New Features
 - [`24ff8bb`](https://github.com/tobymao/sqlglot/commit/24ff8bb6c1d94a03f6611d4353e210108c25a6a6) - **duckdb**: Add transpilation support for COLLATE function *(PR [#7461](https://github.com/tobymao/sqlglot/pull/7461) by [@fivetran-amrutabhimsenayachit](https://github.com/fivetran-amrutabhimsenayachit))*
@@ -14137,3 +14147,5 @@ pip install "sqlglot[c]"   # compiled — faster, but no subclassing
 [v30.2.1]: https://github.com/tobymao/sqlglot/compare/v30.2.0...v30.2.1
 [v30.3.0]: https://github.com/tobymao/sqlglot/compare/v30.2.1...v30.3.0
 [v30.4.0]: https://github.com/tobymao/sqlglot/compare/v30.3.0...v30.4.0
+[v30.4.2]: https://github.com/tobymao/sqlglot/compare/v30.4.1...v30.4.2
+[v30.4.3]: https://github.com/tobymao/sqlglot/compare/v30.4.2...v30.4.3

{sqlglot-30.4.2/sqlglot.egg-info → sqlglot-30.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlglot
-Version: 30.4.2
+Version: 30.5.0
 Summary: An easily customizable SQL parser and transpiler
 Author-email: Toby Mao <toby.mao@gmail.com>
 License-Expression: MIT
@@ -33,10 +33,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.4.2; extra == "c"
+Requires-Dist: sqlglotc==30.5.0; extra == "c"
 Provides-Extra: rs
 Requires-Dist: sqlglotrs==0.13.0; extra == "rs"
-Requires-Dist: sqlglotc==30.4.2; extra == "rs"
+Requires-Dist: sqlglotc==30.5.0; extra == "rs"
 Dynamic: license-file
 Dynamic: provides-extra
 

{sqlglot-30.4.2 → sqlglot-30.5.0}/sqlglot/_typing.py

@@ -29,6 +29,7 @@ class ParserNoDialectArgs(t.TypedDict, total=False):
     error_level: ErrorLevel | None
     error_message_context: int
     max_errors: int
+    max_nodes: int
 
 
 class ParserArgs(ParserNoDialectArgs, _DialectArg, total=False):

{sqlglot-30.4.2 → sqlglot-30.5.0}/sqlglot/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '30.4.2'
-__version_tuple__ = version_tuple = (30, 4, 2)
+__version__ = version = '30.5.0'
+__version_tuple__ = version_tuple = (30, 5, 0)
 
-__commit_id__ = commit_id = 'gd04595e1b'
+__commit_id__ = commit_id = 'g64d385f36'

{sqlglot-30.4.2 → sqlglot-30.5.0}/sqlglot/dialects/bigquery.py

@@ -183,6 +183,7 @@ 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,

{sqlglot-30.4.2 → sqlglot-30.5.0}/sqlglot/dialects/dialect.py

@@ -1598,6 +1598,7 @@ def build_date_delta(
 
 def build_date_delta_with_interval(
     expression_class: Type[E],
+    default_unit: str | None = None,
 ) -> t.Callable[[BuilderArgs], E | None]:
     def _builder(args: BuilderArgs) -> E | None:
         if len(args) < 2:
@@ -1606,7 +1607,13 @@ def build_date_delta_with_interval(
         interval = args[1]
 
         if not isinstance(interval, exp.Interval):
-            raise ParseError(f"INTERVAL expression expected but got '{interval}'")
+            if default_unit is None:
+                raise ParseError(f"INTERVAL expression expected but got '{interval}'")
+            return expression_class(
+                this=args[0],
+                expression=interval,
+                unit=exp.Literal.string(default_unit),
+            )
 
         return expression_class(this=args[0], expression=interval.this, unit=unit_to_str(interval))
 

{sqlglot-30.4.2 → sqlglot-30.5.0}/sqlglot/dialects/duckdb.py

@@ -116,6 +116,8 @@ class DuckDB(Dialect):
             "$": TokenType.PARAMETER,
         }
 
+        VAR_SINGLE_TOKENS = {"$"}
+
         COMMANDS = tokens.Tokenizer.COMMANDS - {TokenType.SHOW}
 
     Parser = DuckDBParser

{sqlglot-30.4.2 → sqlglot-30.5.0}/sqlglot/dialects/exasol.py

@@ -61,6 +61,7 @@ class Exasol(Dialect):
             "REGEXP_LIKE": TokenType.RLIKE,
             "SEPARATOR": TokenType.SEPARATOR,
             "SYSTIMESTAMP": TokenType.SYSTIMESTAMP,
+            "MINUS": TokenType.EXCEPT,
         }
         KEYWORDS.pop("DIV")
 

{sqlglot-30.4.2 → sqlglot-30.5.0}/sqlglot/expressions/constraints.py

@@ -33,6 +33,10 @@ class AutoIncrementColumnConstraint(Expression, ColumnConstraintKind):
     pass
 
 
+class InvisibleColumnConstraint(Expression, ColumnConstraintKind):
+    arg_types = {}
+
+
 class ZeroFillColumnConstraint(ColumnConstraint):
     arg_types = {}
 

{sqlglot-30.4.2 → sqlglot-30.5.0}/sqlglot/expressions/ddl.py

@@ -279,6 +279,10 @@ class AlterRename(Expression):
     pass
 
 
+class RenameIndex(Expression):
+    arg_types = {"this": True, "to": True}
+
+
 class AlterModifySqlSecurity(Expression):
     arg_types = {"expressions": True}
 

{sqlglot-30.4.2 → sqlglot-30.5.0}/sqlglot/expressions/dml.py

@@ -79,6 +79,7 @@ class Delete(Expression, DML):
         "limit": False,
         "tables": False,  # Multiple-Table Syntax (MySQL)
         "cluster": False,  # Clickhouse
+        "hint": False,
     }
 
     def delete(
@@ -282,7 +283,8 @@ class LoadData(Expression):
         "this": True,
         "local": False,
         "overwrite": False,
-        "inpath": True,
+        "inpath": False,
+        "files": False,
         "partition": False,
         "input_format": False,
         "serde": False,
@@ -300,6 +302,7 @@ class Update(Expression, DML):
         "order": False,
         "limit": False,
         "options": False,
+        "hint": False,
     }
 
     def table(

{sqlglot-30.4.2 → sqlglot-30.5.0}/sqlglot/expressions/functions.py

@@ -321,6 +321,24 @@ class AIClassify(Expression, Func):
     _sql_names = ["AI_CLASSIFY"]
 
 
+class AIEmbed(Expression, Func):
+    arg_types = {"expressions": True}
+    is_var_len_args = True
+    _sql_names = ["AI_EMBED"]
+
+
+class AISimilarity(Expression, Func):
+    arg_types = {"expressions": True}
+    is_var_len_args = True
+    _sql_names = ["AI_SIMILARITY"]
+
+
+class AIGenerate(Expression, Func):
+    arg_types = {"expressions": True}
+    is_var_len_args = True
+    _sql_names = ["AI_GENERATE"]
+
+
 class FeaturesAtTime(Expression, Func):
     arg_types = {"this": True, "time": False, "num_rows": False, "ignore_feature_nulls": False}
 

{sqlglot-30.4.2 → sqlglot-30.5.0}/sqlglot/expressions/math.py

@@ -108,7 +108,12 @@ class EuclideanDistance(Expression, Func):
 
 
 class JarowinklerSimilarity(Expression, Func):
-    arg_types = {"this": True, "expression": True, "case_insensitive": False}
+    arg_types = {
+        "this": True,
+        "expression": True,
+        "case_insensitive": False,
+        "integer_scale": False,
+    }
 
 
 class ManhattanDistance(Expression, Func):

{sqlglot-30.4.2 → sqlglot-30.5.0}/sqlglot/expressions/string.py

@@ -220,7 +220,7 @@ class Stuff(Expression, Func):
 
 class Substring(Expression, Func):
     _sql_names = ["SUBSTRING", "SUBSTR"]
-    arg_types = {"this": True, "start": False, "length": False}
+    arg_types = {"this": True, "start": False, "length": False, "zero_start": False}
 
 
 class SubstringIndex(Expression, Func):

{sqlglot-30.4.2 → sqlglot-30.5.0}/sqlglot/generator.py

@@ -234,6 +234,7 @@ class Generator:
         exp.ProjectionPolicyColumnConstraint: lambda self, e: (
             f"PROJECTION POLICY {self.sql(e, 'this')}"
         ),
+        exp.InvisibleColumnConstraint: lambda self, e: "INVISIBLE",
         exp.ZeroFillColumnConstraint: lambda self, e: "ZEROFILL",
         exp.Put: lambda self, e: self.get_put_sql(e),
         exp.RemoteWithConnectionModelProperty: lambda self, e: (
@@ -320,6 +321,9 @@ class Generator:
     # Whether MERGE ... WHEN MATCHED BY SOURCE is allowed
     MATCHED_BY_SOURCE = True
 
+    # Whether MERGE ... WHEN MATCHED/NOT MATCHED THEN UPDATE/INSERT ... WHERE is supported
+    SUPPORTS_MERGE_WHERE = False
+
     # Whether the INTERVAL expression works only with values like '1 day'
     SINGLE_STRING_INTERVAL = False
 
@@ -1681,6 +1685,7 @@ class Generator:
         return f"{local}DIRECTORY {self.sql(expression, 'this')}{row_format}"
 
     def delete_sql(self, expression: exp.Delete) -> str:
+        hint = self.sql(expression, "hint")
         this = self.sql(expression, "this")
         this = f" FROM {this}" if this else ""
         using = self.expressions(expression, key="using")
@@ -1697,7 +1702,7 @@ class Generator:
             expression_sql = f"{this}{using}{cluster}{where}{returning}{order}{limit}"
         else:
             expression_sql = f"{returning}{this}{using}{cluster}{where}{order}{limit}"
-        return self.prepend_ctes(expression, f"DELETE{tables}{expression_sql}")
+        return self.prepend_ctes(expression, f"DELETE{hint}{tables}{expression_sql}")
 
     def drop_sql(self, expression: exp.Drop) -> str:
         this = self.sql(expression, "this")
@@ -2463,6 +2468,7 @@ class Generator:
         return (join_sql, "")
 
     def update_sql(self, expression: exp.Update) -> str:
+        hint = self.sql(expression, "hint")
         this = self.sql(expression, "this")
         join_sql, from_sql = self._update_from_joins_sql(expression)
         set_sql = self.expressions(expression, flat=True)
@@ -2476,7 +2482,7 @@ class Generator:
             expression_sql = f"{returning}{from_sql}{where_sql}"
         options = self.expressions(expression, key="options")
         options = f" OPTION({options})" if options else ""
-        sql = f"UPDATE {this}{join_sql} SET {set_sql}{expression_sql}{order}{limit}{options}"
+        sql = f"UPDATE{hint} {this}{join_sql} SET {set_sql}{expression_sql}{order}{limit}{options}"
         return self.prepend_ctes(expression, sql)
 
     def values_sql(self, expression: exp.Values, values_as_table: bool = True) -> str:
@@ -2811,10 +2817,20 @@ class Generator:
         return self._replace_line_breaks(text).replace(delimiter, escaped_delimiter)
 
     def loaddata_sql(self, expression: exp.LoadData) -> str:
+        is_overwrite = expression.args.get("overwrite")
+        overwrite = " OVERWRITE" if is_overwrite else ""
+        this = self.sql(expression, "this")
+
+        files = expression.args.get("files")
+        if files:
+            files_sql = self.expressions(files, flat=True)
+            files_sql = f"FILES{self.wrap(files_sql)}"
+            this = f" {this}" if is_overwrite else f" INTO TABLE {this}"
+            return f"LOAD DATA{overwrite}{this} FROM {files_sql}"
+
         local = " LOCAL" if expression.args.get("local") else ""
         inpath = f" INPATH {self.sql(expression, 'inpath')}"
-        overwrite = " OVERWRITE" if expression.args.get("overwrite") else ""
-        this = f" INTO TABLE {self.sql(expression, 'this')}"
+        this = f" INTO TABLE {this}"
         partition = self.sql(expression, "partition")
         partition = f" {partition}" if partition else ""
         input_format = self.sql(expression, "input_format")
@@ -4448,9 +4464,16 @@ class Generator:
             else:
                 expressions_sql = self.expressions(then_expression)
                 then = f"UPDATE SET{self.sep()}{expressions_sql}" if expressions_sql else "UPDATE"
-
         else:
             then = self.sql(then_expression)
+
+        if isinstance(then_expression, (exp.Insert, exp.Update)):
+            where = self.sql(then_expression, "where")
+            if where and not self.SUPPORTS_MERGE_WHERE:
+                kind = "INSERT" if isinstance(then_expression, exp.Insert) else "UPDATE"
+                self.unsupported(f"WHERE clause in MERGE {kind} is not supported")
+                where = ""
+            then = f"{then}{where}"
         return f"WHEN {matched}{source}{condition} THEN {then}"
 
     def whens_sql(self, expression: exp.Whens) -> str:
@@ -5899,3 +5922,8 @@ class Generator:
     def usingproperty_sql(self, expression: exp.UsingProperty) -> str:
         kind = expression.args.get("kind")
         return f"USING {kind} {self.sql(expression, 'this')}"
+
+    def renameindex_sql(self, expression: exp.RenameIndex) -> str:
+        this = self.sql(expression, "this")
+        to = self.sql(expression, "to")
+        return f"RENAME INDEX {this} TO {to}"

{sqlglot-30.4.2 → sqlglot-30.5.0}/sqlglot/generators/bigquery.py

@@ -272,6 +272,9 @@ class BigQueryGenerator(generator.Generator):
 
     TRANSFORMS = {
         **generator.Generator.TRANSFORMS,
+        exp.AIEmbed: rename_func("EMBED"),
+        exp.AIGenerate: rename_func("GENERATE"),
+        exp.AISimilarity: rename_func("SIMILARITY"),
         exp.ApproxTopK: rename_func("APPROX_TOP_COUNT"),
         exp.ApproxDistinct: rename_func("APPROX_COUNT_DISTINCT"),
         exp.ArgMax: arg_max_or_min_no_count("MAX_BY"),

{sqlglot-30.4.2 → sqlglot-30.5.0}/sqlglot/generators/clickhouse.py

@@ -416,6 +416,32 @@ class ClickHouseGenerator(generator.Generator):
         exp.DType.MULTIPOLYGON,
     }
 
+    def groupconcat_sql(self, expression: exp.GroupConcat) -> str:
+        this = expression.this
+        separator = expression.args.get("separator")
+
+        if isinstance(this, exp.Limit) and this.this:
+            limit = this
+            this = limit.this.pop()
+            return self.sql(
+                exp.ParameterizedAgg(
+                    this="groupConcat",
+                    params=[this],
+                    expressions=[separator, limit.expression],
+                )
+            )
+
+        if separator:
+            return self.sql(
+                exp.ParameterizedAgg(
+                    this="groupConcat",
+                    params=[this],
+                    expressions=[separator],
+                )
+            )
+
+        return self.func("groupConcat", this)
+
     def offset_sql(self, expression: exp.Offset) -> str:
         offset = super().offset_sql(expression)
 

{sqlglot-30.4.2 → sqlglot-30.5.0}/sqlglot/generators/duckdb.py

@@ -24,7 +24,6 @@ from sqlglot.dialects.dialect import (
     getbit_sql,
     groupconcat_sql,
     inline_array_unless_query,
-    jarowinkler_similarity,
     months_between_sql,
     no_datetime_sql,
     no_comment_column_constraint_sql,
@@ -1537,7 +1536,6 @@ class DuckDBGenerator(generator.Generator):
         exp.BitwiseOrAgg: _bitwise_agg_sql,
         exp.BitwiseRightShift: _bitshift_sql,
         exp.BitwiseXorAgg: _bitwise_agg_sql,
-        exp.ByteLength: lambda self, e: self.func("OCTET_LENGTH", e.this),
         exp.CommentColumnConstraint: no_comment_column_constraint_sql,
         exp.Corr: lambda self, e: self._corr_sql(e),
         exp.CosineDistance: rename_func("LIST_COSINE_DISTANCE"),
@@ -1609,7 +1607,6 @@ class DuckDBGenerator(generator.Generator):
         ),
         exp.Ceil: _ceil_floor,
         exp.Floor: _ceil_floor,
-        exp.JarowinklerSimilarity: jarowinkler_similarity("JARO_WINKLER_SIMILARITY"),
         exp.JSONBExists: rename_func("JSON_EXISTS"),
         exp.JSONExtract: _arrow_json_extract_sql,
         exp.JSONExtractArray: _json_extract_value_array_sql,
@@ -2259,6 +2256,47 @@ class DuckDBGenerator(generator.Generator):
         self.unsupported("DuckDB does not support the COMPRESS() function")
         return self.function_fallback_sql(expression)
 
+    def encrypt_sql(self, expression: exp.Encrypt) -> str:
+        self.unsupported("ENCRYPT is not supported in DuckDB")
+        return self.function_fallback_sql(expression)
+
+    def decrypt_sql(self, expression: exp.Decrypt) -> str:
+        func_name = "TRY_DECRYPT" if expression.args.get("safe") else "DECRYPT"
+        self.unsupported(f"{func_name} is not supported in DuckDB")
+        return self.function_fallback_sql(expression)
+
+    def decryptraw_sql(self, expression: exp.DecryptRaw) -> str:
+        func_name = "TRY_DECRYPT_RAW" if expression.args.get("safe") else "DECRYPT_RAW"
+        self.unsupported(f"{func_name} is not supported in DuckDB")
+        return self.function_fallback_sql(expression)
+
+    def encryptraw_sql(self, expression: exp.EncryptRaw) -> str:
+        self.unsupported("ENCRYPT_RAW is not supported in DuckDB")
+        return self.function_fallback_sql(expression)
+
+    def parseurl_sql(self, expression: exp.ParseUrl) -> str:
+        self.unsupported("PARSE_URL is not supported in DuckDB")
+        return self.function_fallback_sql(expression)
+
+    def parseip_sql(self, expression: exp.ParseIp) -> str:
+        self.unsupported("PARSE_IP is not supported in DuckDB")
+        return self.function_fallback_sql(expression)
+
+    def jarowinklersimilarity_sql(self, expression: exp.JarowinklerSimilarity) -> str:
+        this = expression.this
+        expr = expression.expression
+
+        if expression.args.get("case_insensitive"):
+            this = exp.Upper(this=this)
+            expr = exp.Upper(this=expr)
+
+        result = exp.func("JARO_WINKLER_SIMILARITY", this, expr)
+
+        if expression.args.get("integer_scale"):
+            result = exp.cast(result * 100, "INTEGER")
+
+        return self.sql(result)
+
     def nthvalue_sql(self, expression: exp.NthValue) -> str:
         from_first = expression.args.get("from_first", True)
         if not from_first:
@@ -2293,6 +2331,17 @@ class DuckDBGenerator(generator.Generator):
         replacements = {"seed": seed_value, "length": length}
         return f"({self.sql(exp.replace_placeholders(self.RANDSTR_TEMPLATE, **replacements))})"
 
+    @unsupported_args("finish")
+    def reduce_sql(self, expression: exp.Reduce) -> str:
+        array_arg = expression.this
+        initial_value = expression.args.get("initial")
+        merge_lambda = expression.args.get("merge")
+
+        if merge_lambda:
+            merge_lambda.set("colon", True)
+
+        return self.func("list_reduce", array_arg, merge_lambda, initial_value)
+
     def zipf_sql(self, expression: exp.Zipf) -> str:
         """
         Transpile Snowflake's ZIPF to DuckDB using CDF-based inverse sampling.
@@ -2431,6 +2480,10 @@ class DuckDBGenerator(generator.Generator):
         from_ = f" FROM {from_}" if from_ else ""
         return f"SHOW {expression.name}{from_}"
 
+    def soundex_sql(self, expression: exp.Soundex) -> str:
+        self.unsupported("SOUNDEX is not supported in DuckDB")
+        return self.func("SOUNDEX", expression.this)
+
     def sortarray_sql(self, expression: exp.SortArray) -> str:
         arr = expression.this
         asc = expression.args.get("asc")
@@ -2504,6 +2557,20 @@ class DuckDBGenerator(generator.Generator):
 
         return strposition_sql(self, expression)
 
+    def substring_sql(self, expression: exp.Substring) -> str:
+        if expression.args.get("zero_start"):
+            start = expression.args.get("start")
+            length = expression.args.get("length")
+
+            if start := expression.args.get("start"):
+                start = exp.If(this=start.eq(0), true=exp.Literal.number(1), false=start)
+            if length := expression.args.get("length"):
+                length = exp.If(this=length < 0, true=exp.Literal.number(0), false=length)
+
+            return self.func("SUBSTRING", expression.this, start, length)
+
+        return self.function_fallback_sql(expression)
+
     def strtotime_sql(self, expression: exp.StrToTime) -> str:
         # Check if target_type requires TIMESTAMPTZ (for LTZ/TZ variants)
         target_type = expression.args.get("target_type")
@@ -3229,6 +3296,10 @@ class DuckDBGenerator(generator.Generator):
             )
         )
 
+    def arrayunionagg_sql(self, expression: exp.ArrayUnionAgg) -> str:
+        self.unsupported("ARRAY_UNION_AGG is not supported in DuckDB")
+        return self.function_fallback_sql(expression)
+
     def arraydistinct_sql(self, expression: exp.ArrayDistinct) -> str:
         arr = expression.this
         func = self.func("LIST_DISTINCT", arr)
@@ -3396,6 +3467,44 @@ class DuckDBGenerator(generator.Generator):
     def rtrimmedlength_sql(self, expression: exp.RtrimmedLength) -> str:
         return self.func("LENGTH", exp.Trim(this=expression.this, position="TRAILING"))
 
+    def stuff_sql(self, expression: exp.Stuff) -> str:
+        base = expression.this
+        start = expression.args["start"]
+        length = expression.args["length"]
+        insertion = expression.expression
+        is_binary = _is_binary(base)
+
+        if is_binary:
+            # DuckDB's SUBSTRING doesn't accept BLOB; operate on the HEX string instead
+            # (each byte = 2 hex chars), then UNHEX back to BLOB
+            base = exp.Hex(this=base)
+            insertion = exp.Hex(this=insertion)
+            left = exp.Substring(
+                this=base.copy(),
+                start=exp.Literal.number(1),
+                length=(start.copy() - exp.Literal.number(1)) * exp.Literal.number(2),
+            )
+            right = exp.Substring(
+                this=base.copy(),
+                start=((start + length) - exp.Literal.number(1)) * exp.Literal.number(2)
+                + exp.Literal.number(1),
+            )
+        else:
+            left = exp.Substring(
+                this=base.copy(),
+                start=exp.Literal.number(1),
+                length=start.copy() - exp.Literal.number(1),
+            )
+            right = exp.Substring(this=base.copy(), start=start + length)
+        result: exp.Expr = exp.DPipe(
+            this=exp.DPipe(this=left, expression=insertion), expression=right
+        )
+
+        if is_binary:
+            result = exp.Unhex(this=result)
+
+        return self.sql(result)
+
     def rand_sql(self, expression: exp.Rand) -> str:
         seed = expression.this
         if seed is not None:
@@ -3416,6 +3525,16 @@ class DuckDBGenerator(generator.Generator):
         # Default DuckDB behavior - just return RANDOM() as float
         return "RANDOM()"
 
+    def bytelength_sql(self, expression: exp.ByteLength) -> str:
+        arg = expression.this
+
+        # Check if it's a text type (handles both literals and annotated expressions)
+        if arg.is_type(*exp.DataType.TEXT_TYPES):
+            return self.func("OCTET_LENGTH", exp.Encode(this=arg))
+
+        # Default: pass through as-is (conservative for DuckDB, handles binary and unannotated)
+        return self.func("OCTET_LENGTH", arg)
+
     def base64encode_sql(self, expression: exp.Base64Encode) -> str:
         # DuckDB TO_BASE64 requires BLOB input
         # Snowflake BASE64_ENCODE accepts both VARCHAR and BINARY - for VARCHAR it implicitly

{sqlglot-30.4.2 → sqlglot-30.5.0}/sqlglot/generators/oracle.py

@@ -25,6 +25,7 @@ class OracleGenerator(generator.Generator):
     TRY_SUPPORTED = False
     SUPPORTS_UESCAPE = False
     LOCKING_READS_SUPPORTED = True
+    SUPPORTS_MERGE_WHERE = True
     JOIN_HINTS = False
     TABLE_HINTS = False
     DATA_TYPE_SPECIFIERS_ALLOWED = True

{sqlglot-30.4.2 → sqlglot-30.5.0}/sqlglot/generators/snowflake.py

@@ -497,6 +497,9 @@ class SnowflakeGenerator(generator.Generator):
         exp.GetExtract: rename_func("GET"),
         exp.GroupConcat: lambda self, e: groupconcat_sql(self, e, sep=""),
         exp.If: if_sql(name="IFF", false_value="NULL"),
+        exp.JSONArray: lambda self, e: self.func(
+            "TO_VARIANT", self.func("ARRAY_CONSTRUCT", *e.expressions)
+        ),
         exp.JSONExtractArray: _json_extract_value_array_sql,
         exp.JSONExtractScalar: lambda self, e: self.func(
             "JSON_EXTRACT_PATH_TEXT", e.this, e.expression
@@ -640,6 +643,7 @@ class SnowflakeGenerator(generator.Generator):
     TYPE_MAPPING = {
         **generator.Generator.TYPE_MAPPING,
         exp.DType.BIGDECIMAL: "DOUBLE",
+        exp.DType.JSON: "VARIANT",
         exp.DType.NESTED: "OBJECT",
         exp.DType.STRUCT: "OBJECT",
         exp.DType.TEXT: "VARCHAR",
@@ -863,7 +867,7 @@ class SnowflakeGenerator(generator.Generator):
     def rowaccessproperty_sql(self, expression: exp.RowAccessProperty) -> str:
         if not expression.this:
             return "ROW ACCESS"
-        on = f" ON ({self.expressions(expression, flat=True)})"
+        on = f" ON ({self.expressions(expression, flat=True)})" if expression.expressions else ""
         return f"WITH ROW ACCESS POLICY {self.sql(expression, 'this')}{on}"
 
     def describe_sql(self, expression: exp.Describe) -> str:

{sqlglot-30.4.2 → sqlglot-30.5.0}/sqlglot/generators/spark.py

@@ -119,6 +119,7 @@ class SparkGenerator(Spark2Generator):
                 f"PARTITIONED BY {self.wrap(self.expressions(sqls=[_normalize_partition(e) for e in e.this.expressions], skip_first=True))}"
             ),
             exp.SafeAdd: rename_func("TRY_ADD"),
+            exp.SafeDivide: rename_func("TRY_DIVIDE"),
             exp.SafeMultiply: rename_func("TRY_MULTIPLY"),
             exp.SafeSubtract: rename_func("TRY_SUBTRACT"),
             exp.StartsWith: rename_func("STARTSWITH"),

{sqlglot-30.4.2 → sqlglot-30.5.0}/sqlglot/generators/starrocks.py

@@ -100,6 +100,14 @@ class StarRocksGenerator(MySQLGenerator):
         exp.JSONExtract: arrow_json_extract_sql,
         exp.Property: property_sql,
         exp.RegexpLike: rename_func("REGEXP"),
+        # Inherited from MySQL, minus operations StarRocks supports natively
+        # (QUALIFY, FULL OUTER JOIN, SEMI/ANTI JOIN)
+        exp.Select: transforms.preprocess(
+            [
+                transforms.eliminate_distinct_on,
+                transforms.unnest_generate_date_array_using_recursive_cte,
+            ]
+        ),
         exp.SchemaCommentProperty: lambda self, e: self.naked_property(e),
         exp.SqlSecurityProperty: lambda self, e: f"SECURITY {self.sql(e.this)}",
         exp.StDistance: st_distance_sphere,