feat(mysql): translate UPDATE … FROM … syntax to UPDATE … JOIN … when generating MySQL

sqlglot/dialects/mysql.py

@@ -1334,3 +1334,53 @@ def ignorenulls_sql(self, expression: exp.IgnoreNulls) -> str:
         @unsupported_args("this")
         def currentschema_sql(self, expression: exp.CurrentSchema) -> str:
             return self.func("SCHEMA")
+
+        def _update_join_clauses_sql(self, from_expression: exp.From) -> str:
+            def join_sql(node: exp.Expression) -> str:
+                if isinstance(node, exp.Join):
+                    join = node.copy()
+                    if not join.args.get("on") and not join.args.get("using"):
+                        join.set("on", exp.true())
+                    return self.sql(join)
+
+                table = node.copy()
+                nested_joins = list(table.args.get("joins") or [])
+                if nested_joins:
+                    table.set("joins", None)
+
+                sql = [self.sql(exp.Join(this=table, on=exp.true()))]
+
+                for nested in nested_joins:
+                    sql.append(join_sql(nested))
+
+                return "".join(sql)
+
+            joins: t.List[str] = []
+
+            if from_expression.this:
+                joins.append(join_sql(from_expression.this))
+
+            for extra in from_expression.expressions or []:
+                joins.append(join_sql(extra))
+
+            return "".join(joins)
+
+        def update_sql(self, expression: exp.Update) -> str:
+            this = self.sql(expression, "this")
+            set_sql = self.expressions(expression, flat=True)
+            from_expression = expression.args.get("from_") or expression.args.get("from")
+            join_sql = self._update_join_clauses_sql(from_expression) if from_expression else ""
+            where_sql = self.sql(expression, "where")
+            returning = self.sql(expression, "returning")
+            order = self.sql(expression, "order")
+            limit = self.sql(expression, "limit")
+            options = self.expressions(expression, key="options")
+            options = f" OPTION({options})" if options else ""
+
+            if self.RETURNING_END:
+                post_set_sql = f"{where_sql}{returning}"
+            else:
+                post_set_sql = f"{returning}{where_sql}"
+
+            sql = f"UPDATE {this}{join_sql} SET {set_sql}{post_set_sql}{order}{limit}{options}"
+            return self.prepend_ctes(expression, sql)

tests/dialects/test_mysql.py

@@ -194,6 +194,17 @@ def test_ddl(self):
         self.validate_identity("ALTER TABLE t ALTER COLUMN c SET INVISIBLE")
         self.validate_identity("ALTER TABLE t ALTER COLUMN c SET VISIBLE")
 
+    def test_update_from_to_join(self):
+        self.validate_all(
+            "UPDATE foo JOIN bar ON TRUE SET a = bar.a WHERE foo.id = bar.id",
+            read={
+                "postgres": "UPDATE foo SET a = bar.a FROM bar WHERE foo.id = bar.id",
+            },
+            write={
+                "mysql": "UPDATE foo JOIN bar ON TRUE SET a = bar.a WHERE foo.id = bar.id",
+            },
+        )
+
     def test_identity(self):
         self.validate_identity("SELECT HIGH_PRIORITY STRAIGHT_JOIN SQL_CALC_FOUND_ROWS * FROM t")
         self.validate_identity("SELECT CAST(COALESCE(`id`, 'NULL') AS CHAR CHARACTER SET binary)")

tests/dialects/test_teradata.py

@@ -70,7 +70,7 @@ def test_update(self):
             "UPDATE A FROM schema.tableA AS A, (SELECT col1 FROM schema.tableA GROUP BY col1) AS B SET col2 = '' WHERE A.col1 = B.col1",
             write={
                 "teradata": "UPDATE A FROM schema.tableA AS A, (SELECT col1 FROM schema.tableA GROUP BY col1) AS B SET col2 = '' WHERE A.col1 = B.col1",
-                "mysql": "UPDATE A SET col2 = '' FROM `schema`.tableA AS A, (SELECT col1 FROM `schema`.tableA GROUP BY col1) AS B WHERE A.col1 = B.col1",
+                "mysql": "UPDATE A JOIN `schema`.tableA AS A ON TRUE JOIN (SELECT col1 FROM `schema`.tableA GROUP BY col1) AS B ON TRUE SET col2 = '' WHERE A.col1 = B.col1",
             },
         )