fix(mysql): accept quoted charset in USING. (#7522)

* fix(mysql): accept quoted charset in `USING`.

MySQL allows backtick-quoted charset names in both `CONVERT(... USING)`
and `CHAR(... USING)`. Both called `_parse_var`, which only matches
unquoted tokens. Adding `TokenType.IDENTIFIER` to the token set accepts
quoted charsets without changing behavior for unquoted ones.

* fix(mysql): Support for `CHAR(... USING BINARY)`.

Handle parsing of `SELECT CHAR(65 USING BINARY)`, which is a valid MySQL
character set.

* fix(mysql): preserve quoted charset names.

Charset names requiring quotes (e.g. spaces from custom XML-registered
charsets per https://dev.mysql.com/doc/refman/8.0/en/identifiers.html)
were roundtripping to invalid SQL. For MySQL, these are now retained as
quoted identifiers while safe names still emit bare.

* fix(mysql): Reuse `SAFE_IDENTFIER_RE`.

Reuse `SAFE_IDENTFIER_RE` instead of using a dialect-specific parallel
copy.

* Update sqlglot/parsers/mysql.py

* Update sqlglot/parser.py

---------

Co-authored-by: Jo <46752250+georgesittas@users.noreply.github.com>

Author: burnison

sqlglot/parser.py

@@ -7599,10 +7599,19 @@ def _parse_char(self) -> exp.Chr:
         return self.expression(
             exp.Chr(
                 expressions=self._parse_csv(self._parse_assignment),
-                charset=self._match(TokenType.USING) and self._parse_var(),
+                charset=self._match(TokenType.USING) and self._parse_charset_name(),
             )
         )
 
+    def _parse_charset_name(self) -> exp.Expr | None:
+        """
+        Parse a charset name after USING or CHARACTER SET. Dialects that need to preserve quoting
+        for specific name shapes override this.
+        """
+        return self._parse_var(
+            tokens={TokenType.BINARY, TokenType.IDENTIFIER},
+        )
+
     def _parse_cast(self, strict: bool, safe: bool | None = None) -> exp.Expr:
         this = self._parse_assignment()
 
@@ -7719,9 +7728,7 @@ def _parse_convert(self, strict: bool, safe: bool | None = None) -> exp.Expr | N
         this = self._parse_bitwise()
 
         if self._match(TokenType.USING):
-            to: exp.Expr | None = exp.DType.CHARACTER_SET.into_expr(
-                kind=self._parse_var(tokens={TokenType.BINARY})
-            )
+            to: exp.Expr | None = exp.DType.CHARACTER_SET.into_expr(kind=self._parse_charset_name())
         elif self._match(TokenType.COMMA):
             to = self._parse_types()
         else:

sqlglot/parsers/mysql.py

@@ -486,6 +486,20 @@ def _parse_set_item_charset(self, kind: str) -> exp.Expr:
         this = self._parse_string() or self._parse_unquoted_field()
         return self.expression(exp.SetItem(this=this, kind=kind))
 
+    def _parse_charset_name(self) -> exp.Expr | None:
+        """
+        Preserve quoting when a charset name has characters that require it (e.g. spaces, as allowed
+        for custom XML-registered charsets). Safe names unwrap to a bare Var so roundtrips remain minimal.
+        """
+        identifier = self._parse_identifier()
+        if identifier:
+            return (
+                exp.Var(this=name)
+                if exp.SAFE_IDENTIFIER_RE.match(name := identifier.name)
+                else identifier
+            )
+        return self._parse_var(tokens={TokenType.BINARY})
+
     def _parse_set_item_names(self) -> exp.Expr:
         charset = self._parse_string() or self._parse_unquoted_field()
         if self._match_text_seq("COLLATE"):

tests/dialects/test_mysql.py

@@ -634,6 +634,30 @@ def test_convert(self):
         self.validate_identity(
             "CONVERT('a' USING binary)", "CAST('a' AS CHAR CHARACTER SET binary)"
         )
+        self.validate_identity(
+            "SELECT CONVERT(`col` USING `utf8mb4`)",
+            "SELECT CAST(`col` AS CHAR CHARACTER SET utf8mb4)",
+        )
+        self.validate_identity(
+            "SELECT CHAR(0xC3A9 USING `utf8mb4`)",
+            "SELECT CHAR(x'C3A9' USING utf8mb4)",
+        )
+        self.validate_identity("SELECT CHAR(65 USING BINARY)")
+        self.validate_identity(
+            "SELECT CHAR(65 USING `binary`)",
+            "SELECT CHAR(65 USING binary)",
+        )
+        self.validate_identity(
+            "SELECT CONVERT(x USING `binary`)",
+            "SELECT CAST(x AS CHAR CHARACTER SET binary)",
+        )
+        self.validate_identity(
+            "SELECT CONVERT(x USING `my charset`)",
+            "SELECT CAST(x AS CHAR CHARACTER SET `my charset`)",
+        )
+        self.validate_identity(
+            "SELECT CHAR(65 USING `my charset`)",
+        )
 
     def test_match_against(self):
         self.validate_all(