Repository: tobymao/sqlglot

Issue:
rows alias is key , execute error 
**Before you file an issue**
- Make sure you specify the "read" dialect eg. `parse_one(sql, read="postgres")`
- Make sure you specify the "write" dialect eg. `ast.sql(dialect="doris")`
- Check if the issue still exists on main:Couldn't find anything related

**Fully reproducible code snippet**
```python
import sqlglot

sql = """SELECT ROW_NUMBER() OVER (ORDER BY 1) AS rows"""

print(sqlglot.transpile(sql ,read="postgres" , write="doris")[0]);
``` 

output
```
SELECT ROW_NUMBER() OVER (ORDER BY 1 NULLS LAST) AS rows
```

Expected output
```
SELECT ROW_NUMBER() OVER (ORDER BY 1 NULLS LAST) AS 'rows'

```
or
```
SELECT ROW_NUMBER() OVER (ORDER BY 1 NULLS LAST) AS "rows"

```

or
```
SELECT ROW_NUMBER() OVER (ORDER BY 1 NULLS LAST) AS `rows`

```








Discussion:
Don't see an issue here:

SQLite:

```
sqlite> SELECT ROW_NUMBER() OVER (ORDER BY 1) AS rows;
1
sqlite> WITH t AS (SELECT ROW_NUMBER() OVER (ORDER BY 1) AS rows) SELECT rows FROM t;
1
```

Postgres:

```
georgesittas=# SELECT ROW_NUMBER() OVER (ORDER BY 1) AS rows;
 rows
------
    1
(1 row)
georgesittas=# WITH t AS (SELECT ROW_NUMBER() OVER (ORDER BY 1) AS rows) SELECT rows FROM t;
 rows
------
    1
(1 row)
```
> Don't see an issue here:
> 
> SQLite:
> 
> ```
> sqlite> SELECT ROW_NUMBER() OVER (ORDER BY 1) AS rows;
> 1
> sqlite> WITH t AS (SELECT ROW_NUMBER() OVER (ORDER BY 1) AS rows) SELECT rows FROM t;
> 1
> ```
> 
> Postgres:
> 
> ```
> georgesittas=# SELECT ROW_NUMBER() OVER (ORDER BY 1) AS rows;
>  rows
> ------
>     1
> (1 row)
> georgesittas=# WITH t AS (SELECT ROW_NUMBER() OVER (ORDER BY 1) AS rows) SELECT rows FROM t;
>  rows
> ------
>     1
> (1 row)
> ```

i am so sorry , it's doris , write = doris
> Don't see an issue here:
> 
> SQLite:
> 
> ```
> sqlite> SELECT ROW_NUMBER() OVER (ORDER BY 1) AS rows;
> 1
> sqlite> WITH t AS (SELECT ROW_NUMBER() OVER (ORDER BY 1) AS rows) SELECT rows FROM t;
> 1
> ```
> 
> Postgres:
> 
> ```
> georgesittas=# SELECT ROW_NUMBER() OVER (ORDER BY 1) AS rows;
>  rows
> ------
>     1
> (1 row)
> georgesittas=# WITH t AS (SELECT ROW_NUMBER() OVER (ORDER BY 1) AS rows) SELECT rows FROM t;
>  rows
> ------
>     1
> (1 row)
> ```

I hope you can handle a request like this, there are many more, but I can learn from your pr, I'm sure I should be able to handle the others, please

Resolving patch:
diff --git a/sqlglot/dialects/mysql.py b/sqlglot/dialects/mysql.py
--- a/sqlglot/dialects/mysql.py
+++ b/sqlglot/dialects/mysql.py
@@ -597,13 +597,13 @@ def _parse_oldstyle_limit(
             return offset, limit
 
         def _parse_set_item_charset(self, kind: str) -> exp.Expression:
-            this = self._parse_string() or self._parse_id_var()
+            this = self._parse_string() or self._parse_unquoted_field()
             return self.expression(exp.SetItem, this=this, kind=kind)
 
         def _parse_set_item_names(self) -> exp.Expression:
-            charset = self._parse_string() or self._parse_id_var()
+            charset = self._parse_string() or self._parse_unquoted_field()
             if self._match_text_seq("COLLATE"):
-                collate = self._parse_string() or self._parse_id_var()
+                collate = self._parse_string() or self._parse_unquoted_field()
             else:
                 collate = None
 
@@ -823,6 +823,295 @@ class Generator(generator.Generator):
             exp.DataType.Type.TIMESTAMPLTZ,
         }
 
+        # https://dev.mysql.com/doc/refman/8.0/en/keywords.html
+        RESERVED_KEYWORDS = {
+            "accessible",
+            "add",
+            "all",
+            "alter",
+            "analyze",
+            "and",
+            "as",
+            "asc",
+            "asensitive",
+            "before",
+            "between",
+            "bigint",
+            "binary",
+            "blob",
+            "both",
+            "by",
+            "call",
+            "cascade",
+            "case",
+            "change",
+            "char",
+            "character",
+            "check",
+            "collate",
+            "column",
+            "condition",
+            "constraint",
+            "continue",
+            "convert",
+            "create",
+            "cross",
+            "cube",
+            "cume_dist",
+            "current_date",
+            "current_time",
+            "current_timestamp",
+            "current_user",
+            "cursor",
+            "database",
+            "databases",
+            "day_hour",
+            "day_microsecond",
+            "day_minute",
+            "day_second",
+            "dec",
+            "decimal",
+            "declare",
+            "default",
+            "delayed",
+            "delete",
+            "dense_rank",
+            "desc",
+            "describe",
+            "deterministic",
+            "distinct",
+            "distinctrow",
+            "div",
+            "double",
+            "drop",
+            "dual",
+            "each",
+            "else",
+            "elseif",
+            "empty",
+            "enclosed",
+            "escaped",
+            "except",
+            "exists",
+            "exit",
+            "explain",
+            "false",
+            "fetch",
+            "first_value",
+            "float",
+            "float4",
+            "float8",
+            "for",
+            "force",
+            "foreign",
+            "from",
+            "fulltext",
+            "function",
+            "generated",
+            "get",
+            "grant",
+            "group",
+            "grouping",
+            "groups",
+            "having",
+            "high_priority",
+            "hour_microsecond",
+            "hour_minute",
+            "hour_second",
+            "if",
+            "ignore",
+            "in",
+            "index",
+            "infile",
+            "inner",
+            "inout",
+            "insensitive",
+            "insert",
+            "int",
+            "int1",
+            "int2",
+            "int3",
+            "int4",
+            "int8",
+            "integer",
+            "intersect",
+            "interval",
+            "into",
+            "io_after_gtids",
+            "io_before_gtids",
+            "is",
+            "iterate",
+            "join",
+            "json_table",
+            "key",
+            "keys",
+            "kill",
+            "lag",
+            "last_value",
+            "lateral",
+            "lead",
+            "leading",
+            "leave",
+            "left",
+            "like",
+            "limit",
+            "linear",
+            "lines",
+            "load",
+            "localtime",
+            "localtimestamp",
+            "lock",
+            "long",
+            "longblob",
+            "longtext",
+            "loop",
+            "low_priority",
+            "master_bind",
+            "master_ssl_verify_server_cert",
+            "match",
+            "maxvalue",
+            "mediumblob",
+            "mediumint",
+            "mediumtext",
+            "middleint",
+            "minute_microsecond",
+            "minute_second",
+            "mod",
+            "modifies",
+            "natural",
+            "not",
+            "no_write_to_binlog",
+            "nth_value",
+            "ntile",
+            "null",
+            "numeric",
+            "of",
+            "on",
+            "optimize",
+            "optimizer_costs",
+            "option",
+            "optionally",
+            "or",
+            "order",
+            "out",
+            "outer",
+            "outfile",
+            "over",
+            "partition",
+            "percent_rank",
+            "precision",
+            "primary",
+            "procedure",
+            "purge",
+            "range",
+            "rank",
+            "read",
+            "reads",
+            "read_write",
+            "real",
+            "recursive",
+            "references",
+            "regexp",
+            "release",
+            "rename",
+            "repeat",
+            "replace",
+            "require",
+            "resignal",
+            "restrict",
+            "return",
+            "revoke",
+            "right",
+            "rlike",
+            "row",
+            "rows",
+            "row_number",
+            "schema",
+            "schemas",
+            "second_microsecond",
+            "select",
+            "sensitive",
+            "separator",
+            "set",
+            "show",
+            "signal",
+            "smallint",
+            "spatial",
+            "specific",
+            "sql",
+            "sqlexception",
+            "sqlstate",
+            "sqlwarning",
+            "sql_big_result",
+            "sql_calc_found_rows",
+            "sql_small_result",
+            "ssl",
+            "starting",
+            "stored",
+            "straight_join",
+            "system",
+            "table",
+            "terminated",
+            "then",
+            "tinyblob",
+            "tinyint",
+            "tinytext",
+            "to",
+            "trailing",
+            "trigger",
+            "true",
+            "undo",
+            "union",
+            "unique",
+            "unlock",
+            "unsigned",
+            "update",
+            "usage",
+            "use",
+            "using",
+            "utc_date",
+            "utc_time",
+            "utc_timestamp",
+            "values",
+            "varbinary",
+            "varchar",
+            "varcharacter",
+            "varying",
+            "virtual",
+            "when",
+            "where",
+            "while",
+            "window",
+            "with",
+            "write",
+            "xor",
+            "year_month",
+            "zerofill",
+            "cume_dist",
+            "dense_rank",
+            "empty",
+            "except",
+            "first_value",
+            "grouping",
+            "groups",
+            "intersect",
+            "json_table",
+            "lag",
+            "last_value",
+            "lateral",
+            "lead",
+            "nth_value",
+            "ntile",
+            "of",
+            "over",
+            "percent_rank",
+            "rank",
+            "recursive",
+            "row_number",
+            "system",
+            "window",
+        }
+
         def array_sql(self, expression: exp.Array) -> str:
             self.unsupported("Arrays are not supported by MySQL")
             return self.function_fallback_sql(expression)
diff --git a/sqlglot/parser.py b/sqlglot/parser.py
--- a/sqlglot/parser.py
+++ b/sqlglot/parser.py
@@ -6246,8 +6246,10 @@ def _parse_set_item_assignment(
             return None
 
         right = self._parse_statement() or self._parse_id_var()
-        this = self.expression(exp.EQ, this=left, expression=right)
+        if isinstance(right, (exp.Column, exp.Identifier)):
+            right = exp.var(right.name)
 
+        this = self.expression(exp.EQ, this=left, expression=right)
         return self.expression(exp.SetItem, this=this, kind=kind)
 
     def _parse_set_transaction(self, global_: bool = False) -> exp.Expression:


Test patch:
diff --git a/tests/dialects/test_mysql.py b/tests/dialects/test_mysql.py
--- a/tests/dialects/test_mysql.py
+++ b/tests/dialects/test_mysql.py
@@ -155,6 +155,10 @@ def test_identity(self):
             """SELECT * FROM foo WHERE 3 MEMBER OF(info->'$.value')""",
             """SELECT * FROM foo WHERE 3 MEMBER OF(JSON_EXTRACT(info, '$.value'))""",
         )
+        self.validate_identity(
+            "SELECT 1 AS row",
+            "SELECT 1 AS `row`",
+        )
 
         # Index hints
         self.validate_identity(
diff --git a/tests/dialects/test_teradata.py b/tests/dialects/test_teradata.py
--- a/tests/dialects/test_teradata.py
+++ b/tests/dialects/test_teradata.py
@@ -38,7 +38,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 SET col2 = '' FROM `schema`.tableA AS A, (SELECT col1 FROM `schema`.tableA GROUP BY col1) AS B WHERE A.col1 = B.col1",
             },
         )