sqlglotc 30.19.0__tar.gz → 30.21.0__tar.gz

{sqlglotc-30.19.0/sqlglotc.egg-info → sqlglotc-30.21.0}/PKG-INFO

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

{sqlglotc-30.19.0 → sqlglotc-30.21.0}/sqlglot/expressions/json.py

@@ -248,4 +248,4 @@ class ParseJSON(Expression, Func):
     # BigQuery, Snowflake have PARSE_JSON, Presto has JSON_PARSE
     # Snowflake also has TRY_PARSE_JSON, which is represented using `safe`
     _sql_names = ["PARSE_JSON", "JSON_PARSE"]
-    arg_types = {"this": True, "expression": False, "safe": False}
+    arg_types = {"this": True, "expression": False, "safe": False, "is_literal": False}

{sqlglotc-30.19.0 → sqlglotc-30.21.0}/sqlglot/expressions/query.py

@@ -804,6 +804,19 @@ class Lateral(Expression, UDTF):
         "ordinality": False,
     }
 
+    @property
+    def selects(self) -> list[Expr]:
+        from sqlglot.expressions.array import Unnest
+
+        columns = super().selects
+
+        # UNNEST ... WITH ORDINALITY stores the ordinality column's name in Unnest.offset
+        offset = self.this.args.get("offset") if isinstance(self.this, Unnest) else None
+        if isinstance(offset, Identifier):
+            columns = columns + [offset]
+
+        return columns
+
 
 class TableFromRows(Expression, UDTF):
     arg_types = {

{sqlglotc-30.19.0 → sqlglotc-30.21.0}/sqlglot/generator.py

@@ -2959,7 +2959,20 @@ class Generator:
             op_sql = self.seg(f"LATERAL VIEW{' OUTER' if expression.args.get('outer') else ''}")
             return f"{op_sql}{self.sep()}{this}{table}{columns}"
 
-        alias = self.sql(expression, "alias")
+        table_alias = expression.args.get("alias")
+        offset = expression.this.args.get("offset")
+
+        if (
+            self.UNNEST_WITH_ORDINALITY
+            and table_alias
+            and isinstance(expression.this, exp.Unnest)
+            and isinstance(offset, exp.Identifier)
+        ):
+            # UNNEST ... WITH ORDINALITY stores the ordinality column's name in Unnest.offset
+            table_alias = table_alias.copy()
+            table_alias.append("columns", offset.copy())
+
+        alias = self.sql(table_alias)
         alias = f" AS {alias}" if alias else ""
 
         ordinality = expression.args.get("ordinality") or ""
@@ -4942,15 +4955,20 @@ class Generator:
     def tonumber_sql(self, expression: exp.ToNumber) -> str:
         if not self.SUPPORTS_TO_NUMBER:
             self.unsupported("Unsupported TO_NUMBER function")
-            return self.sql(exp.cast(expression.this, exp.DType.DOUBLE))
+            return self._tonumber_cast_sql(expression)
 
         fmt = expression.args.get("format")
         if not fmt:
             self.unsupported("Conversion format is required for TO_NUMBER")
-            return self.sql(exp.cast(expression.this, exp.DType.DOUBLE))
+            return self._tonumber_cast_sql(expression)
 
         return self.func("TO_NUMBER", expression.this, fmt)
 
+    def _tonumber_cast_sql(self, expression: exp.ToNumber) -> str:
+        if expression.args.get("safe"):
+            return self.sql(exp.TryCast(this=expression.this, to=exp.DataType.build("DOUBLE")))
+        return self.sql(exp.cast(expression.this, exp.DType.DOUBLE))
+
     def dictproperty_sql(self, expression: exp.DictProperty) -> str:
         this = self.sql(expression, "this")
         kind = self.sql(expression, "kind")
@@ -5304,6 +5322,28 @@ class Generator:
             sqlglot.dialects.dialect.unit_to_str(expression),
         )
 
+    def arrayinsert_sql(self, expression: exp.ArrayInsert, index_offset: int = 0) -> str:
+        this = expression.this
+        position = expression.args["position"]
+        offset = index_offset - (expression.args.get("offset") or 0)
+
+        if offset:
+            if position.is_int:
+                value = position.to_py()
+                if value >= 0:
+                    position = exp.Literal.number(value + offset)
+                elif offset < 0 and value == -1:
+                    # 1-based -1 appends, which a 0-based position can only express as the size
+                    position = exp.ArraySize(this=this.copy())
+                else:
+                    # Negative positions count from the end, so they shift in the opposite
+                    # direction, e.g. 0-based -1 (before the last element) is 1-based -2
+                    position = exp.Literal.number(value - offset)
+            else:
+                self.unsupported("ARRAY_INSERT position can only be converted if it's a literal")
+
+        return self.func("ARRAY_INSERT", this, position, expression.expression)
+
     def arrayany_sql(self, expression: exp.ArrayAny) -> str:
         if self.CAN_IMPLEMENT_ARRAY_ANY:
             filtered = exp.ArrayFilter(this=expression.this, expression=expression.expression)

{sqlglotc-30.19.0 → sqlglotc-30.21.0}/sqlglot/generators/athena.py

@@ -122,7 +122,7 @@ class AthenaTrinoGenerator(TrinoGenerator):
     }
 
 
-class AthenaGenerator(generator.Generator):
+class AthenaGenerator(AthenaTrinoGenerator):
     SELECT_KINDS: tuple[str, ...] = ()
     SUPPORTS_DECODE_CASE = False
 

{sqlglotc-30.19.0 → sqlglotc-30.21.0}/sqlglot/generators/bigquery.py

@@ -713,6 +713,11 @@ class BigQueryGenerator(generator.Generator):
 
         return self.func("CONTAINS_SUBSTR", this, expr, expression.args.get("json_scope"))
 
+    def parsejson_sql(self, expression: exp.ParseJSON) -> str:
+        if expression.args.get("is_literal"):
+            return f"JSON {self.sql(expression, 'this')}"
+        return super().parsejson_sql(expression)
+
     def cast_sql(self, expression: exp.Cast, safe_prefix: str | None = None) -> str:
         this = expression.this
 

{sqlglotc-30.19.0 → sqlglotc-30.21.0}/sqlglot/generators/clickhouse.py

@@ -370,6 +370,7 @@ class ClickHouseGenerator(generator.Generator):
         exp.UnixToTime: _unix_to_time_sql,
         exp.Trim: lambda self, e: trim_sql(self, e, default_trim_type="BOTH"),
         exp.Variance: rename_func("varSamp"),
+        exp.VariancePop: rename_func("varPop"),
         exp.SchemaCommentProperty: lambda self, e: self.naked_property(e),
         exp.Stddev: rename_func("stddevSamp"),
         exp.Chr: rename_func("CHAR"),

{sqlglotc-30.19.0 → sqlglotc-30.21.0}/sqlglot/generators/duckdb.py

@@ -2577,11 +2577,10 @@ class DuckDBGenerator(generator.Generator):
         scale = expression.args.get("scale")
 
         if not fmt and precision and scale:
-            return self.sql(
-                exp.cast(
-                    expression.this, f"DECIMAL({precision.name}, {scale.name})", dialect="duckdb"
-                )
-            )
+            to = exp.DataType.build(f"DECIMAL({precision.name}, {scale.name})", dialect="duckdb")
+            if expression.args.get("safe"):
+                return self.sql(exp.TryCast(this=expression.this, to=to))
+            return self.sql(exp.cast(expression.this, to, dialect="duckdb"))
 
         return super().tonumber_sql(expression)
 
@@ -3075,6 +3074,9 @@ class DuckDBGenerator(generator.Generator):
         if milli or nano:
             expression.set("sec", sec)
 
+        if zone := expression.args.get("zone"):
+            return self.sql(exp.AtTimeZone(this=expression, zone=zone.pop()))
+
         return rename_func("MAKE_TIMESTAMP")(self, expression)
 
     @unsupported_args("nano")

{sqlglotc-30.19.0 → sqlglotc-30.21.0}/sqlglot/generators/mysql.py

@@ -154,9 +154,9 @@ class MySQLGenerator(generator.Generator):
         exp.DateDiff: remove_ts_or_ds_to_date(
             lambda self, e: self.func("DATEDIFF", e.this, e.expression), ("this", "expression")
         ),
-        exp.DateAdd: remove_ts_or_ds_to_date(date_add_sql("ADD")),
+        exp.DateAdd: date_add_sql("ADD"),
         exp.DateStrToDate: datestrtodate_sql,
-        exp.DateSub: remove_ts_or_ds_to_date(date_add_sql("SUB")),
+        exp.DateSub: date_add_sql("SUB"),
         exp.DateTrunc: _date_trunc_sql,
         exp.Day: remove_ts_or_ds_to_date(),
         exp.DayOfMonth: remove_ts_or_ds_to_date(rename_func("DAYOFMONTH")),

{sqlglotc-30.19.0 → sqlglotc-30.21.0}/sqlglot/generators/singlestore.py

@@ -1529,7 +1529,12 @@ class SingleStoreGenerator(MySQLGenerator):
 
     def collate_sql(self, expression: exp.Collate) -> str:
         # SingleStore does not support setting a collation for column in the SELECT query,
-        # so we cast column to a LONGTEXT type with specific collation
+        # so we cast column to a LONGTEXT type with specific collation. If the cast is
+        # already there (e.g. when regenerating previously generated SQL), don't add
+        # another one, so that generation stays idempotent.
+        this = expression.this
+        if isinstance(this, exp.Cast) and this.to.this == exp.DType.LONGTEXT:
+            return self.binary(expression, "COLLATE")
         return self.binary(expression, ":> LONGTEXT COLLATE")
 
     def currentdate_sql(self, expression: exp.CurrentDate) -> str:

{sqlglotc-30.19.0 → sqlglotc-30.21.0}/sqlglot/generators/spark.py

@@ -95,9 +95,6 @@ class SparkGenerator(Spark2Generator):
             exp.ArrayConstructCompact: lambda self, e: self.func(
                 "ARRAY_COMPACT", self.func("ARRAY", *e.expressions)
             ),
-            exp.ArrayInsert: lambda self, e: self.func(
-                "ARRAY_INSERT", e.this, e.args.get("position"), e.expression
-            ),
             exp.ArrayAppend: array_append_sql("ARRAY_APPEND"),
             exp.ArrayPrepend: array_append_sql("ARRAY_PREPEND"),
             exp.BitwiseAndAgg: rename_func("BIT_AND"),
@@ -152,6 +149,9 @@ class SparkGenerator(Spark2Generator):
     def ignorenulls_sql(self, expression: exp.IgnoreNulls) -> str:
         return generator.Generator.ignorenulls_sql(self, expression)
 
+    def arrayinsert_sql(self, expression: exp.ArrayInsert, index_offset: int = 0) -> str:
+        return super().arrayinsert_sql(expression, index_offset=1)
+
     def bracket_sql(self, expression: exp.Bracket) -> str:
         if expression.args.get("safe"):
             key = seq_get(self.bracket_offset_expressions(expression, index_offset=1), 0)

{sqlglotc-30.19.0 → sqlglotc-30.21.0}/sqlglot/generators/spark2.py

@@ -220,6 +220,16 @@ class Spark2Generator(HiveGenerator):
 
     def cast_sql(self, expression: exp.Cast, safe_prefix: str | None = None) -> str:
         arg = expression.this
+        if (
+            isinstance(arg, exp.Literal)
+            and arg.is_number
+            and expression.to.is_type(exp.DType.DECIMAL)
+            and len(expression.to.expressions) == 2
+            and isinstance(expression.to.expressions[1].this, exp.Neg)
+        ):
+            # Spark 2 supports negative scales in literals, but not in DECIMAL type syntax.
+            return f"{self.sql(arg)}BD"
+
         is_json_extract = isinstance(
             arg, (exp.JSONExtract, exp.JSONExtractScalar)
         ) and not arg.args.get("variant_extract")

{sqlglotc-30.19.0 → sqlglotc-30.21.0}/sqlglot/generators/sqlite.py

@@ -20,7 +20,7 @@ from sqlglot.tokens import TokenType
 
 
 def _transform_create(expression: exp.Expr) -> exp.Expr:
-    """Move primary key to a column and enforce auto_increment on primary keys."""
+    """Move primary key to a column and place auto_increment after it."""
     schema = expression.this
 
     if isinstance(expression, exp.Create) and isinstance(schema, exp.Schema):
@@ -52,12 +52,9 @@ def _transform_create(expression: exp.Expr) -> exp.Expr:
                     auto_increment = constraint
                     auto_increment_index = i
 
-            if auto_increment is not None and (
-                primary_key_index == -1 or auto_increment_index < primary_key_index
-            ):
+            if auto_increment is not None and 0 <= auto_increment_index < primary_key_index:
                 column.constraints.remove(auto_increment)
-                if primary_key_index != -1:
-                    column.constraints.insert(primary_key_index, auto_increment)
+                column.constraints.insert(primary_key_index, auto_increment)
 
     return expression
 
@@ -206,6 +203,16 @@ class SQLiteGenerator(generator.Generator):
 
     LIMIT_FETCH = "LIMIT"
 
+    def autoincrementcolumnconstraint_sql(
+        self, expression: exp.AutoIncrementColumnConstraint
+    ) -> str:
+        column = expression.find_ancestor(exp.ColumnDef)
+        if column and column.find(exp.PrimaryKeyColumnConstraint):
+            return super().autoincrementcolumnconstraint_sql(expression)
+
+        self.unsupported("SQLite AUTOINCREMENT requires an INTEGER PRIMARY KEY")
+        return ""
+
     def insert_sql(self, expression: exp.Insert) -> str:
         if expression.args.get("ignore"):
             expression.set("ignore", False)

{sqlglotc-30.19.0 → sqlglotc-30.21.0}/sqlglot/generators/starrocks.py

@@ -12,6 +12,7 @@ from sqlglot.dialects.dialect import (
     property_sql,
     var_map_sql,
 )
+from sqlglot.generator import Generator
 from sqlglot.generators.mysql import MySQLGenerator
 
 
@@ -292,6 +293,24 @@ class StarRocksGenerator(MySQLGenerator):
         "with",
     }
 
+    def ignorenulls_sql(self, expression: exp.IgnoreNulls) -> str:
+        # IGNORE NULLS follows the first argument, e.g. LAG(x IGNORE NULLS, 1, 0)
+        # https://docs.starrocks.io/docs/sql-reference/sql-functions/Window_function/
+        func = expression.this
+        if isinstance(func, (exp.FirstValue, exp.LastValue, exp.Lag, exp.Lead)):
+            return self.func(
+                func.sql_name(),
+                Generator.ignorenulls_sql(self, exp.IgnoreNulls(this=func.this)),
+                func.args.get("offset"),
+                func.args.get("default"),
+            )
+
+        return super().ignorenulls_sql(expression)
+
+    def respectnulls_sql(self, expression: exp.RespectNulls) -> str:
+        # RESPECT NULLS is the default behavior, and StarRocks rejects the keyword
+        return self.sql(expression, "this")
+
     def create_sql(self, expression: exp.Create) -> str:
         # Starrocks' primary key is defined outside of the schema, so we need to move it there
         schema = expression.this

{sqlglotc-30.19.0 → sqlglotc-30.21.0}/sqlglot/optimizer/canonicalize_internal_names.py

@@ -205,10 +205,12 @@ def canonicalize_internal_names(expression: E) -> E:
                             ],
                         )
 
-                # BigQuery UNNEST ... WITH OFFSET AS <id> declares a pseudo-column via
-                # the offset arg (not the alias).
-                if isinstance(alias_holder, exp.Unnest):
-                    offset_id = alias_holder.args.get("offset")
+                # UNNEST stores its offset column outside the alias, including under LATERAL.
+                unnest = (
+                    alias_holder.this if isinstance(alias_holder, exp.Lateral) else alias_holder
+                )
+                if isinstance(unnest, exp.Unnest):
+                    offset_id = unnest.args.get("offset")
                     if isinstance(offset_id, exp.Identifier) and offset_id.name in name_map:
                         _canon(offset_id, name_map[offset_id.name])
 

{sqlglotc-30.19.0 → sqlglotc-30.21.0}/sqlglot/optimizer/qualify_columns.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import itertools
 import re
 import typing as t
+from collections import Counter
 
 from sqlglot import alias, exp
 from sqlglot.dialects.dialect import Dialect, DialectType
@@ -492,6 +493,8 @@ def _expand_order_by_and_distinct_on(scope: Scope, resolver: Resolver) -> None:
     if not isinstance(expression, exp.Selectable):
         return
 
+    alias_names = {name for name, count in Counter(expression.named_selects).items() if count == 1}
+
     # TODO (mypyc): rebind to exp.Expr to avoid Selectable trait vtable dispatch for .args
     expr: exp.Expr = expression
 
@@ -510,7 +513,7 @@ def _expand_order_by_and_distinct_on(scope: Scope, resolver: Resolver) -> None:
         for original, expanded in zip(
             modifier_expressions,
             _expand_positional_references(
-                scope, modifier_expressions, resolver.dialect, alias=True
+                scope, modifier_expressions, resolver.dialect, alias_names=alias_names
             ),
         ):
             for agg in original.find_all(exp.AggFunc):
@@ -521,18 +524,23 @@ def _expand_order_by_and_distinct_on(scope: Scope, resolver: Resolver) -> None:
             original.replace(expanded)
 
         if expr.args.get("group"):
-            selects = {s.this: exp.column(s.alias_or_name) for s in expression.selects}
+            selects = {
+                s.this: exp.column(s.alias_or_name)
+                for s in expression.selects
+                if s.alias_or_name in alias_names
+            }
 
             for node in modifier_expressions:
-                node.replace(
-                    exp.to_identifier(_select_by_pos(expression, node).alias)
-                    if node.is_int
-                    else selects.get(node, node)
-                )
+                # Remaining ordinals reference duplicate aliases and must stay positional.
+                if not node.is_int:
+                    node.replace(selects.get(node, node))
 
 
 def _expand_positional_references(
-    scope: Scope, expressions: Iterable[exp.Expr], dialect: Dialect, alias: bool = False
+    scope: Scope,
+    expressions: Iterable[exp.Expr],
+    dialect: Dialect,
+    alias_names: set[str] | None = None,
 ) -> list[exp.Expr]:
     new_nodes: list[exp.Expr] = []
     ambiguous_projections = None
@@ -546,8 +554,10 @@ def _expand_positional_references(
         if node.is_int and isinstance(node, exp.Literal):
             select = _select_by_pos(expression, node)
 
-            if alias:
-                new_nodes.append(exp.column(select.args["alias"].copy()))
+            if alias_names is not None:
+                new_nodes.append(
+                    exp.column(select.args["alias"].copy()) if select.alias in alias_names else node
+                )
             else:
                 # TODO (mypyc): use a separate variable to avoid reusing `select` (Alias) with a different type
                 select_expr: exp.Expr = select.this
@@ -606,11 +616,25 @@ def _convert_columns_to_dots(scope: Scope, resolver: Resolver) -> None:
         is_star = isinstance(column.this, exp.Star)
         column_table: str | exp.Identifier | None = column.table
         dot_parts = column.meta.pop("dot_parts", [])
+        root_resolver: Resolver | None = None
+        if not is_star and column.db and column_table in scope.selected_sources:
+            root, field = column.parts[:2]
+            for candidate_resolver in itertools.chain((resolver,), resolver.outer_resolvers()):
+                if root.name not in candidate_resolver.scope.selected_sources:
+                    continue
+                if field.name in candidate_resolver.get_source_columns(root.name):
+                    root_resolver = candidate_resolver
+                break
         if (
             column_table
-            and (column_table not in scope.selected_sources or (is_star and column.db))
             and (
-                is_star
+                column_table not in scope.selected_sources
+                or (is_star and column.db)
+                or root_resolver
+            )
+            and (
+                root_resolver
+                or is_star
                 or not scope.parent
                 or column_table not in scope.parent.sources
                 or not scope.is_correlated_subquery
@@ -619,10 +643,11 @@ def _convert_columns_to_dots(scope: Scope, resolver: Resolver) -> None:
             root, *parts = column.parts
             was_qualified = False
 
-            # Unlike columns, correlated stars can't be deferred to the outer scopes, since they
-            # must be expanded in this one, so they're resolved against those scopes as well
+            # Correlated stars cannot be deferred; qualified paths use their root source's resolver.
             resolvers: t.Iterable[Resolver] = (
-                itertools.chain((resolver,), resolver.outer_resolvers()) if is_star else (resolver,)
+                itertools.chain((resolver,), resolver.outer_resolvers())
+                if is_star
+                else (root_resolver or resolver,)
             )
             for source_resolver in resolvers:
                 selected_sources = source_resolver.scope.selected_sources

{sqlglotc-30.19.0 → sqlglotc-30.21.0}/sqlglot/optimizer/resolver.py

@@ -43,22 +43,26 @@ class Resolver:
         """
         column_name = column if isinstance(column, str) else column.name
 
-        table_name = self._get_table_name_from_sources(column_name)
+        join_context = (
+            self._get_column_join_context(column) if isinstance(column, exp.Column) else None
+        )
+        is_semi_or_anti_join = join_context is not None and join_context.is_semi_or_anti_join
+
+        # A SEMI/ANTI join's own table is excluded from the global lookup below, so skip it here
+        table_name = (
+            None if is_semi_or_anti_join else self._get_table_name_from_sources(column_name)
+        )
 
-        if not table_name and isinstance(column, exp.Column):
+        if not table_name and join_context is not None:
             # Fall-back case: If we couldn't find the `table_name` from ALL of the sources,
             # attempt to disambiguate the column based on other characteristics e.g if this column is in a join condition,
             # we may be able to disambiguate based on the source order.
-            if join_context := self._get_column_join_context(column):
-                # In this case, the return value will be the join that _may_ be able to disambiguate the column
-                # and we can use the source columns available at that join to get the table name
-                # catch OptimizeError if column is still ambiguous and try to resolve with schema inference below
-                try:
-                    table_name = self._get_table_name_from_sources(
-                        column_name, self._get_available_source_columns(join_context)
-                    )
-                except OptimizeError:
-                    pass
+            try:
+                table_name = self._get_table_name_from_sources(
+                    column_name, self._get_available_source_columns(join_context)
+                )
+            except OptimizeError:
+                pass
 
         if not table_name and self._infer_schema:
             sources_without_schema = tuple(

{sqlglotc-30.19.0 → sqlglotc-30.21.0}/sqlglot/optimizer/simplify.py

@@ -707,7 +707,7 @@ class Simplifier:
                 joins.append(node)
 
         for where in wheres:
-            if always_true(where.this):
+            if always_true(where.this) and not isinstance(where.parent, exp.Filter):
                 where.pop()
         for join in joins:
             # Only an inner join can become a CROSS JOIN: a cross join is empty as soon as either
@@ -841,7 +841,10 @@ class Simplifier:
                 if complement_subquery_predicate:
                     right = complement_subquery_predicate(this=right.this)
 
-                return self.COMPLEMENT_COMPARISONS[this.__class__](this=this.this, expression=right)
+                return exp.paren(
+                    self.COMPLEMENT_COMPARISONS[this.__class__](this=this.this, expression=right),
+                    copy=False,
+                )
             if isinstance(this, exp.Paren):
                 condition = this.unnest()
                 if isinstance(condition, exp.And):

{sqlglotc-30.19.0 → sqlglotc-30.21.0}/sqlglot/parser.py

@@ -1633,7 +1633,9 @@ class Parser:
     SHOW_PARSERS: t.ClassVar[dict[str, t.Callable]] = {}
 
     TYPE_LITERAL_PARSERS: t.ClassVar = {
-        exp.DType.JSON: lambda self, this, _: self.expression(exp.ParseJSON(this=this)),
+        exp.DType.JSON: lambda self, this, _: self.expression(
+            exp.ParseJSON(this=this, is_literal=True)
+        ),
     }
 
     TYPE_CONVERTERS: t.ClassVar[dict[exp.DType, t.Callable[[exp.DataType], exp.DataType]]] = {}
@@ -3693,7 +3695,7 @@ class Parser:
                 settings=self._match_text_seq("SETTINGS") and self._parse_settings_property(),
                 default=self._match_text_seq("DEFAULT", "VALUES"),
                 expression=set_values
-                or self._parse_derived_table_values()
+                or self._parse_derived_table_values(allow_value_synonym=True)
                 or self._parse_ddl_select(),
                 conflict=self._parse_on_conflict(),
                 returning=returning or self._parse_returning(),
@@ -3738,7 +3740,7 @@ class Parser:
         action = self._parse_var_from_options(self.CONFLICT_ACTIONS)
         if self._prev.token_type == TokenType.UPDATE:
             self._match(TokenType.SET)
-            expressions = self._parse_csv(self._parse_equality)
+            expressions = self._parse_csv(self._parse_update_assignment)
         else:
             expressions = None
 
@@ -3867,6 +3869,15 @@ class Parser:
             )
         )
 
+    def _parse_update_assignment(self) -> exp.Expr | None:
+        this = self._parse_comparison()
+        if self._match(TokenType.EQ):
+            comments = self._prev_comments
+            this = self.expression(
+                exp.EQ(this=this, expression=self._parse_disjunction()), comments=comments
+            )
+        return this
+
     def _parse_update(self) -> exp.Update:
         hint = self._parse_hint()
         kwargs: dict[str, object] = {
@@ -3875,7 +3886,7 @@ class Parser:
         }
         while self._curr:
             if self._match(TokenType.SET):
-                kwargs["expressions"] = self._parse_csv(self._parse_equality)
+                kwargs["expressions"] = self._parse_csv(self._parse_update_assignment)
             elif self._match(TokenType.RETURNING, advance=False):
                 kwargs["returning"] = self._parse_returning()
             elif self._match(TokenType.FROM, advance=False):
@@ -5259,11 +5270,14 @@ class Parser:
 
         return self.expression(exp.Unnest(expressions=expressions, alias=alias, offset=offset))
 
-    def _parse_derived_table_values(self) -> exp.Values | None:
+    def _parse_derived_table_values(self, allow_value_synonym: bool = False) -> exp.Values | None:
         is_derived = self._match_pair(TokenType.L_PAREN, TokenType.VALUES)
         if not is_derived and not (
             # ClickHouse's `FORMAT Values` is equivalent to `VALUES`
-            self._match_text_seq("VALUES") or self._match_text_seq("FORMAT", "VALUES")
+            self._match_text_seq("VALUES")
+            or self._match_text_seq("FORMAT", "VALUES")
+            # MySQL accepts VALUE as a synonym for VALUES in INSERT statements.
+            or (allow_value_synonym and self._match_text_seq("VALUE"))
         ):
             return None
 
@@ -5766,7 +5780,7 @@ class Parser:
 
     def _parse_limit_options(self) -> exp.LimitOptions | None:
         percent = self._match_set((TokenType.PERCENT, TokenType.MOD))
-        rows = self._match_set((TokenType.ROW, TokenType.ROWS))
+        rows = self._match_texts(("ROW", "ROWS"))
         self._match_text_seq("ONLY")
         with_ties = self._match_text_seq("WITH", "TIES")
 
@@ -5830,7 +5844,11 @@ class Parser:
                 else "FIRST"
             )
 
-            count = self._parse_field(tokens=self.FETCH_TOKENS)
+            count = (
+                None
+                if self._match_texts(("ROW", "ROWS"), advance=False)
+                else self._parse_field(tokens=self.FETCH_TOKENS)
+            )
 
             return self.expression(
                 exp.Fetch(
@@ -5845,7 +5863,7 @@ class Parser:
             return this
 
         count = self._parse_term()
-        self._match_set((TokenType.ROW, TokenType.ROWS))
+        self._match_texts(("ROW", "ROWS"))
 
         return self.expression(
             exp.Offset(this=this, expression=count, expressions=self._parse_limit_by())
@@ -7782,10 +7800,11 @@ class Parser:
             and self._next.text.upper() in self.PROCEDURE_OPTIONS
         )
 
+        index = self._index
         if not procedure_option_follows and self._match_texts(self.CONSTRAINT_PARSERS):
             constraint = self.CONSTRAINT_PARSERS[self._prev.text.upper()](self)
             if not constraint:
-                self._retreat(self._index - 1)
+                self._retreat(index)
                 return None
 
             return self.expression(exp.ColumnConstraint(this=this, kind=constraint))
@@ -9577,7 +9596,7 @@ class Parser:
                     then = self.expression(
                         exp.Update(
                             expressions=self._match(TokenType.SET)
-                            and self._parse_csv(self._parse_equality),
+                            and self._parse_csv(self._parse_update_assignment),
                             where=self._parse_where(),
                         )
                     )