sqlglot.dialects.mysql

  1from __future__ import annotations
  2
  3from sqlglot import exp, generator, parser, tokens
  4from sqlglot.dialects.dialect import (
  5    Dialect,
  6    arrow_json_extract_scalar_sql,
  7    locate_to_strposition,
  8    max_or_greatest,
  9    min_or_least,
 10    no_ilike_sql,
 11    no_paren_current_date_sql,
 12    no_tablesample_sql,
 13    no_trycast_sql,
 14    rename_func,
 15    strposition_to_locate_sql,
 16)
 17from sqlglot.helper import seq_get
 18from sqlglot.tokens import TokenType
 19
 20
 21def _show_parser(*args, **kwargs):
 22    def _parse(self):
 23        return self._parse_show_mysql(*args, **kwargs)
 24
 25    return _parse
 26
 27
 28def _date_trunc_sql(self, expression):
 29    expr = self.sql(expression, "this")
 30    unit = expression.text("unit")
 31
 32    if unit == "day":
 33        return f"DATE({expr})"
 34
 35    if unit == "week":
 36        concat = f"CONCAT(YEAR({expr}), ' ', WEEK({expr}, 1), ' 1')"
 37        date_format = "%Y %u %w"
 38    elif unit == "month":
 39        concat = f"CONCAT(YEAR({expr}), ' ', MONTH({expr}), ' 1')"
 40        date_format = "%Y %c %e"
 41    elif unit == "quarter":
 42        concat = f"CONCAT(YEAR({expr}), ' ', QUARTER({expr}) * 3 - 2, ' 1')"
 43        date_format = "%Y %c %e"
 44    elif unit == "year":
 45        concat = f"CONCAT(YEAR({expr}), ' 1 1')"
 46        date_format = "%Y %c %e"
 47    else:
 48        self.unsupported(f"Unexpected interval unit: {unit}")
 49        return f"DATE({expr})"
 50
 51    return f"STR_TO_DATE({concat}, '{date_format}')"
 52
 53
 54def _str_to_date(args):
 55    date_format = MySQL.format_time(seq_get(args, 1))
 56    return exp.StrToDate(this=seq_get(args, 0), format=date_format)
 57
 58
 59def _str_to_date_sql(self, expression):
 60    date_format = self.format_time(expression)
 61    return f"STR_TO_DATE({self.sql(expression.this)}, {date_format})"
 62
 63
 64def _trim_sql(self, expression):
 65    target = self.sql(expression, "this")
 66    trim_type = self.sql(expression, "position")
 67    remove_chars = self.sql(expression, "expression")
 68
 69    # Use TRIM/LTRIM/RTRIM syntax if the expression isn't mysql-specific
 70    if not remove_chars:
 71        return self.trim_sql(expression)
 72
 73    trim_type = f"{trim_type} " if trim_type else ""
 74    remove_chars = f"{remove_chars} " if remove_chars else ""
 75    from_part = "FROM " if trim_type or remove_chars else ""
 76    return f"TRIM({trim_type}{remove_chars}{from_part}{target})"
 77
 78
 79def _date_add(expression_class):
 80    def func(args):
 81        interval = seq_get(args, 1)
 82        return expression_class(
 83            this=seq_get(args, 0),
 84            expression=interval.this,
 85            unit=exp.Literal.string(interval.text("unit").lower()),
 86        )
 87
 88    return func
 89
 90
 91def _date_add_sql(kind):
 92    def func(self, expression):
 93        this = self.sql(expression, "this")
 94        unit = expression.text("unit").upper() or "DAY"
 95        return (
 96            f"DATE_{kind}({this}, {self.sql(exp.Interval(this=expression.expression, unit=unit))})"
 97        )
 98
 99    return func
100
101
102class MySQL(Dialect):
103    time_format = "'%Y-%m-%d %T'"
104
105    # https://prestodb.io/docs/current/functions/datetime.html#mysql-date-functions
106    time_mapping = {
107        "%M": "%B",
108        "%c": "%-m",
109        "%e": "%-d",
110        "%h": "%I",
111        "%i": "%M",
112        "%s": "%S",
113        "%S": "%S",
114        "%u": "%W",
115        "%k": "%-H",
116        "%l": "%-I",
117        "%T": "%H:%M:%S",
118    }
119
120    class Tokenizer(tokens.Tokenizer):
121        QUOTES = ["'", '"']
122        COMMENTS = ["--", "#", ("/*", "*/")]
123        IDENTIFIERS = ["`"]
124        STRING_ESCAPES = ["'", "\\"]
125        BIT_STRINGS = [("b'", "'"), ("B'", "'"), ("0b", "")]
126        HEX_STRINGS = [("x'", "'"), ("X'", "'"), ("0x", "")]
127
128        KEYWORDS = {
129            **tokens.Tokenizer.KEYWORDS,
130            "MEDIUMTEXT": TokenType.MEDIUMTEXT,
131            "LONGTEXT": TokenType.LONGTEXT,
132            "MEDIUMBLOB": TokenType.MEDIUMBLOB,
133            "LONGBLOB": TokenType.LONGBLOB,
134            "START": TokenType.BEGIN,
135            "SEPARATOR": TokenType.SEPARATOR,
136            "_ARMSCII8": TokenType.INTRODUCER,
137            "_ASCII": TokenType.INTRODUCER,
138            "_BIG5": TokenType.INTRODUCER,
139            "_BINARY": TokenType.INTRODUCER,
140            "_CP1250": TokenType.INTRODUCER,
141            "_CP1251": TokenType.INTRODUCER,
142            "_CP1256": TokenType.INTRODUCER,
143            "_CP1257": TokenType.INTRODUCER,
144            "_CP850": TokenType.INTRODUCER,
145            "_CP852": TokenType.INTRODUCER,
146            "_CP866": TokenType.INTRODUCER,
147            "_CP932": TokenType.INTRODUCER,
148            "_DEC8": TokenType.INTRODUCER,
149            "_EUCJPMS": TokenType.INTRODUCER,
150            "_EUCKR": TokenType.INTRODUCER,
151            "_GB18030": TokenType.INTRODUCER,
152            "_GB2312": TokenType.INTRODUCER,
153            "_GBK": TokenType.INTRODUCER,
154            "_GEOSTD8": TokenType.INTRODUCER,
155            "_GREEK": TokenType.INTRODUCER,
156            "_HEBREW": TokenType.INTRODUCER,
157            "_HP8": TokenType.INTRODUCER,
158            "_KEYBCS2": TokenType.INTRODUCER,
159            "_KOI8R": TokenType.INTRODUCER,
160            "_KOI8U": TokenType.INTRODUCER,
161            "_LATIN1": TokenType.INTRODUCER,
162            "_LATIN2": TokenType.INTRODUCER,
163            "_LATIN5": TokenType.INTRODUCER,
164            "_LATIN7": TokenType.INTRODUCER,
165            "_MACCE": TokenType.INTRODUCER,
166            "_MACROMAN": TokenType.INTRODUCER,
167            "_SJIS": TokenType.INTRODUCER,
168            "_SWE7": TokenType.INTRODUCER,
169            "_TIS620": TokenType.INTRODUCER,
170            "_UCS2": TokenType.INTRODUCER,
171            "_UJIS": TokenType.INTRODUCER,
172            # https://dev.mysql.com/doc/refman/8.0/en/string-literals.html
173            "_UTF8": TokenType.INTRODUCER,
174            "_UTF16": TokenType.INTRODUCER,
175            "_UTF16LE": TokenType.INTRODUCER,
176            "_UTF32": TokenType.INTRODUCER,
177            "_UTF8MB3": TokenType.INTRODUCER,
178            "_UTF8MB4": TokenType.INTRODUCER,
179            "@@": TokenType.SESSION_PARAMETER,
180        }
181
182        COMMANDS = tokens.Tokenizer.COMMANDS - {TokenType.SHOW}
183
184    class Parser(parser.Parser):
185        FUNC_TOKENS = {*parser.Parser.FUNC_TOKENS, TokenType.SCHEMA, TokenType.DATABASE}  # type: ignore
186
187        FUNCTIONS = {
188            **parser.Parser.FUNCTIONS,  # type: ignore
189            "DATE_ADD": _date_add(exp.DateAdd),
190            "DATE_SUB": _date_add(exp.DateSub),
191            "STR_TO_DATE": _str_to_date,
192            "LOCATE": locate_to_strposition,
193            "INSTR": lambda args: exp.StrPosition(substr=seq_get(args, 1), this=seq_get(args, 0)),
194            "LEFT": lambda args: exp.Substring(
195                this=seq_get(args, 0), start=exp.Literal.number(1), length=seq_get(args, 1)
196            ),
197        }
198
199        FUNCTION_PARSERS = {
200            **parser.Parser.FUNCTION_PARSERS,  # type: ignore
201            "GROUP_CONCAT": lambda self: self.expression(
202                exp.GroupConcat,
203                this=self._parse_lambda(),
204                separator=self._match(TokenType.SEPARATOR) and self._parse_field(),
205            ),
206        }
207
208        PROPERTY_PARSERS = {
209            **parser.Parser.PROPERTY_PARSERS,  # type: ignore
210            "ENGINE": lambda self: self._parse_property_assignment(exp.EngineProperty),
211        }
212
213        STATEMENT_PARSERS = {
214            **parser.Parser.STATEMENT_PARSERS,  # type: ignore
215            TokenType.SHOW: lambda self: self._parse_show(),
216        }
217
218        SHOW_PARSERS = {
219            "BINARY LOGS": _show_parser("BINARY LOGS"),
220            "MASTER LOGS": _show_parser("BINARY LOGS"),
221            "BINLOG EVENTS": _show_parser("BINLOG EVENTS"),
222            "CHARACTER SET": _show_parser("CHARACTER SET"),
223            "CHARSET": _show_parser("CHARACTER SET"),
224            "COLLATION": _show_parser("COLLATION"),
225            "FULL COLUMNS": _show_parser("COLUMNS", target="FROM", full=True),
226            "COLUMNS": _show_parser("COLUMNS", target="FROM"),
227            "CREATE DATABASE": _show_parser("CREATE DATABASE", target=True),
228            "CREATE EVENT": _show_parser("CREATE EVENT", target=True),
229            "CREATE FUNCTION": _show_parser("CREATE FUNCTION", target=True),
230            "CREATE PROCEDURE": _show_parser("CREATE PROCEDURE", target=True),
231            "CREATE TABLE": _show_parser("CREATE TABLE", target=True),
232            "CREATE TRIGGER": _show_parser("CREATE TRIGGER", target=True),
233            "CREATE VIEW": _show_parser("CREATE VIEW", target=True),
234            "DATABASES": _show_parser("DATABASES"),
235            "ENGINE": _show_parser("ENGINE", target=True),
236            "STORAGE ENGINES": _show_parser("ENGINES"),
237            "ENGINES": _show_parser("ENGINES"),
238            "ERRORS": _show_parser("ERRORS"),
239            "EVENTS": _show_parser("EVENTS"),
240            "FUNCTION CODE": _show_parser("FUNCTION CODE", target=True),
241            "FUNCTION STATUS": _show_parser("FUNCTION STATUS"),
242            "GRANTS": _show_parser("GRANTS", target="FOR"),
243            "INDEX": _show_parser("INDEX", target="FROM"),
244            "MASTER STATUS": _show_parser("MASTER STATUS"),
245            "OPEN TABLES": _show_parser("OPEN TABLES"),
246            "PLUGINS": _show_parser("PLUGINS"),
247            "PROCEDURE CODE": _show_parser("PROCEDURE CODE", target=True),
248            "PROCEDURE STATUS": _show_parser("PROCEDURE STATUS"),
249            "PRIVILEGES": _show_parser("PRIVILEGES"),
250            "FULL PROCESSLIST": _show_parser("PROCESSLIST", full=True),
251            "PROCESSLIST": _show_parser("PROCESSLIST"),
252            "PROFILE": _show_parser("PROFILE"),
253            "PROFILES": _show_parser("PROFILES"),
254            "RELAYLOG EVENTS": _show_parser("RELAYLOG EVENTS"),
255            "REPLICAS": _show_parser("REPLICAS"),
256            "SLAVE HOSTS": _show_parser("REPLICAS"),
257            "REPLICA STATUS": _show_parser("REPLICA STATUS"),
258            "SLAVE STATUS": _show_parser("REPLICA STATUS"),
259            "GLOBAL STATUS": _show_parser("STATUS", global_=True),
260            "SESSION STATUS": _show_parser("STATUS"),
261            "STATUS": _show_parser("STATUS"),
262            "TABLE STATUS": _show_parser("TABLE STATUS"),
263            "FULL TABLES": _show_parser("TABLES", full=True),
264            "TABLES": _show_parser("TABLES"),
265            "TRIGGERS": _show_parser("TRIGGERS"),
266            "GLOBAL VARIABLES": _show_parser("VARIABLES", global_=True),
267            "SESSION VARIABLES": _show_parser("VARIABLES"),
268            "VARIABLES": _show_parser("VARIABLES"),
269            "WARNINGS": _show_parser("WARNINGS"),
270        }
271
272        SET_PARSERS = {
273            **parser.Parser.SET_PARSERS,
274            "PERSIST": lambda self: self._parse_set_item_assignment("PERSIST"),
275            "PERSIST_ONLY": lambda self: self._parse_set_item_assignment("PERSIST_ONLY"),
276            "CHARACTER SET": lambda self: self._parse_set_item_charset("CHARACTER SET"),
277            "CHARSET": lambda self: self._parse_set_item_charset("CHARACTER SET"),
278            "NAMES": lambda self: self._parse_set_item_names(),
279        }
280
281        PROFILE_TYPES = {
282            "ALL",
283            "BLOCK IO",
284            "CONTEXT SWITCHES",
285            "CPU",
286            "IPC",
287            "MEMORY",
288            "PAGE FAULTS",
289            "SOURCE",
290            "SWAPS",
291        }
292
293        def _parse_show_mysql(self, this, target=False, full=None, global_=None):
294            if target:
295                if isinstance(target, str):
296                    self._match_text_seq(target)
297                target_id = self._parse_id_var()
298            else:
299                target_id = None
300
301            log = self._parse_string() if self._match_text_seq("IN") else None
302
303            if this in {"BINLOG EVENTS", "RELAYLOG EVENTS"}:
304                position = self._parse_number() if self._match_text_seq("FROM") else None
305                db = None
306            else:
307                position = None
308                db = None
309
310                if self._match(TokenType.FROM):
311                    db = self._parse_id_var()
312                elif self._match(TokenType.DOT):
313                    db = target_id
314                    target_id = self._parse_id_var()
315
316            channel = self._parse_id_var() if self._match_text_seq("FOR", "CHANNEL") else None
317
318            like = self._parse_string() if self._match_text_seq("LIKE") else None
319            where = self._parse_where()
320
321            if this == "PROFILE":
322                types = self._parse_csv(lambda: self._parse_var_from_options(self.PROFILE_TYPES))
323                query = self._parse_number() if self._match_text_seq("FOR", "QUERY") else None
324                offset = self._parse_number() if self._match_text_seq("OFFSET") else None
325                limit = self._parse_number() if self._match_text_seq("LIMIT") else None
326            else:
327                types, query = None, None
328                offset, limit = self._parse_oldstyle_limit()
329
330            mutex = True if self._match_text_seq("MUTEX") else None
331            mutex = False if self._match_text_seq("STATUS") else mutex
332
333            return self.expression(
334                exp.Show,
335                this=this,
336                target=target_id,
337                full=full,
338                log=log,
339                position=position,
340                db=db,
341                channel=channel,
342                like=like,
343                where=where,
344                types=types,
345                query=query,
346                offset=offset,
347                limit=limit,
348                mutex=mutex,
349                **{"global": global_},
350            )
351
352        def _parse_oldstyle_limit(self):
353            limit = None
354            offset = None
355            if self._match_text_seq("LIMIT"):
356                parts = self._parse_csv(self._parse_number)
357                if len(parts) == 1:
358                    limit = parts[0]
359                elif len(parts) == 2:
360                    limit = parts[1]
361                    offset = parts[0]
362            return offset, limit
363
364        def _parse_set_item_charset(self, kind):
365            this = self._parse_string() or self._parse_id_var()
366
367            return self.expression(
368                exp.SetItem,
369                this=this,
370                kind=kind,
371            )
372
373        def _parse_set_item_names(self):
374            charset = self._parse_string() or self._parse_id_var()
375            if self._match_text_seq("COLLATE"):
376                collate = self._parse_string() or self._parse_id_var()
377            else:
378                collate = None
379            return self.expression(
380                exp.SetItem,
381                this=charset,
382                collate=collate,
383                kind="NAMES",
384            )
385
386    class Generator(generator.Generator):
387        LOCKING_READS_SUPPORTED = True
388        NULL_ORDERING_SUPPORTED = False
389
390        TRANSFORMS = {
391            **generator.Generator.TRANSFORMS,  # type: ignore
392            exp.CurrentDate: no_paren_current_date_sql,
393            exp.CurrentTimestamp: lambda *_: "CURRENT_TIMESTAMP",
394            exp.ILike: no_ilike_sql,
395            exp.JSONExtractScalar: arrow_json_extract_scalar_sql,
396            exp.Max: max_or_greatest,
397            exp.Min: min_or_least,
398            exp.TableSample: no_tablesample_sql,
399            exp.TryCast: no_trycast_sql,
400            exp.DateAdd: _date_add_sql("ADD"),
401            exp.DateDiff: lambda self, e: f"DATEDIFF({self.format_args(e.this, e.expression)})",
402            exp.DateSub: _date_add_sql("SUB"),
403            exp.DateTrunc: _date_trunc_sql,
404            exp.DayOfWeek: rename_func("DAYOFWEEK"),
405            exp.DayOfMonth: rename_func("DAYOFMONTH"),
406            exp.DayOfYear: rename_func("DAYOFYEAR"),
407            exp.WeekOfYear: rename_func("WEEKOFYEAR"),
408            exp.GroupConcat: lambda self, e: f"""GROUP_CONCAT({self.sql(e, "this")} SEPARATOR {self.sql(e, "separator") or "','"})""",
409            exp.StrToDate: _str_to_date_sql,
410            exp.StrToTime: _str_to_date_sql,
411            exp.Trim: _trim_sql,
412            exp.NullSafeEQ: lambda self, e: self.binary(e, "<=>"),
413            exp.NullSafeNEQ: lambda self, e: self.not_sql(self.binary(e, "<=>")),
414            exp.StrPosition: strposition_to_locate_sql,
415        }
416
417        TYPE_MAPPING = generator.Generator.TYPE_MAPPING.copy()
418        TYPE_MAPPING.pop(exp.DataType.Type.MEDIUMTEXT)
419        TYPE_MAPPING.pop(exp.DataType.Type.LONGTEXT)
420        TYPE_MAPPING.pop(exp.DataType.Type.MEDIUMBLOB)
421        TYPE_MAPPING.pop(exp.DataType.Type.LONGBLOB)
422
423        PROPERTIES_LOCATION = {
424            **generator.Generator.PROPERTIES_LOCATION,  # type: ignore
425            exp.TransientProperty: exp.Properties.Location.UNSUPPORTED,
426        }
427
428        LIMIT_FETCH = "LIMIT"
429
430        def show_sql(self, expression):
431            this = f" {expression.name}"
432            full = " FULL" if expression.args.get("full") else ""
433            global_ = " GLOBAL" if expression.args.get("global") else ""
434
435            target = self.sql(expression, "target")
436            target = f" {target}" if target else ""
437            if expression.name in {"COLUMNS", "INDEX"}:
438                target = f" FROM{target}"
439            elif expression.name == "GRANTS":
440                target = f" FOR{target}"
441
442            db = self._prefixed_sql("FROM", expression, "db")
443
444            like = self._prefixed_sql("LIKE", expression, "like")
445            where = self.sql(expression, "where")
446
447            types = self.expressions(expression, key="types")
448            types = f" {types}" if types else types
449            query = self._prefixed_sql("FOR QUERY", expression, "query")
450
451            if expression.name == "PROFILE":
452                offset = self._prefixed_sql("OFFSET", expression, "offset")
453                limit = self._prefixed_sql("LIMIT", expression, "limit")
454            else:
455                offset = ""
456                limit = self._oldstyle_limit_sql(expression)
457
458            log = self._prefixed_sql("IN", expression, "log")
459            position = self._prefixed_sql("FROM", expression, "position")
460
461            channel = self._prefixed_sql("FOR CHANNEL", expression, "channel")
462
463            if expression.name == "ENGINE":
464                mutex_or_status = " MUTEX" if expression.args.get("mutex") else " STATUS"
465            else:
466                mutex_or_status = ""
467
468            return f"SHOW{full}{global_}{this}{target}{types}{db}{query}{log}{position}{channel}{mutex_or_status}{like}{where}{offset}{limit}"
469
470        def _prefixed_sql(self, prefix, expression, arg):
471            sql = self.sql(expression, arg)
472            if not sql:
473                return ""
474            return f" {prefix} {sql}"
475
476        def _oldstyle_limit_sql(self, expression):
477            limit = self.sql(expression, "limit")
478            offset = self.sql(expression, "offset")
479            if limit:
480                limit_offset = f"{offset}, {limit}" if offset else limit
481                return f" LIMIT {limit_offset}"
482            return ""