sqlglot.dialects.singlestore

   1import re
   2
   3from sqlglot import TokenType
   4import typing as t
   5
   6from sqlglot import exp
   7from sqlglot.dialects.dialect import (
   8    build_formatted_time,
   9    build_json_extract_path,
  10    json_extract_segments,
  11    json_path_key_only_name,
  12    rename_func,
  13    bool_xor_sql,
  14    count_if_to_sum,
  15    timestamptrunc_sql,
  16    date_add_interval_sql,
  17    timestampdiff_sql,
  18)
  19from sqlglot.dialects.mysql import MySQL, _remove_ts_or_ds_to_date, date_add_sql, _show_parser
  20from sqlglot.expressions import DataType
  21from sqlglot.generator import unsupported_args
  22from sqlglot.helper import seq_get
  23
  24
  25def cast_to_time6(
  26    expression: t.Optional[exp.Expression], time_type: DataType.Type = exp.DataType.Type.TIME
  27) -> exp.Cast:
  28    return exp.Cast(
  29        this=expression,
  30        to=exp.DataType.build(
  31            time_type,
  32            expressions=[exp.DataTypeParam(this=exp.Literal.number(6))],
  33        ),
  34    )
  35
  36
  37class SingleStore(MySQL):
  38    SUPPORTS_ORDER_BY_ALL = True
  39
  40    TIME_MAPPING: t.Dict[str, str] = {
  41        "D": "%u",  # Day of week (1-7)
  42        "DD": "%d",  # day of month (01-31)
  43        "DY": "%a",  # abbreviated name of day
  44        "HH": "%I",  # Hour of day (01-12)
  45        "HH12": "%I",  # alias for HH
  46        "HH24": "%H",  # Hour of day (00-23)
  47        "MI": "%M",  # Minute (00-59)
  48        "MM": "%m",  # Month (01-12; January = 01)
  49        "MON": "%b",  # Abbreviated name of month
  50        "MONTH": "%B",  # Name of month
  51        "SS": "%S",  # Second (00-59)
  52        "RR": "%y",  # 15
  53        "YY": "%y",  # 15
  54        "YYYY": "%Y",  # 2015
  55        "FF6": "%f",  # only 6 digits are supported in python formats
  56    }
  57
  58    VECTOR_TYPE_ALIASES = {
  59        "I8": "TINYINT",
  60        "I16": "SMALLINT",
  61        "I32": "INT",
  62        "I64": "BIGINT",
  63        "F32": "FLOAT",
  64        "F64": "DOUBLE",
  65    }
  66
  67    INVERSE_VECTOR_TYPE_ALIASES = {v: k for k, v in VECTOR_TYPE_ALIASES.items()}
  68
  69    class Tokenizer(MySQL.Tokenizer):
  70        BYTE_STRINGS = [("e'", "'"), ("E'", "'")]
  71
  72        KEYWORDS = {
  73            **MySQL.Tokenizer.KEYWORDS,
  74            "BSON": TokenType.JSONB,
  75            "GEOGRAPHYPOINT": TokenType.GEOGRAPHYPOINT,
  76            "TIMESTAMP": TokenType.TIMESTAMP,
  77            "UTC_DATE": TokenType.UTC_DATE,
  78            "UTC_TIME": TokenType.UTC_TIME,
  79            "UTC_TIMESTAMP": TokenType.UTC_TIMESTAMP,
  80            ":>": TokenType.COLON_GT,
  81            "!:>": TokenType.NCOLON_GT,
  82            "::$": TokenType.DCOLONDOLLAR,
  83            "::%": TokenType.DCOLONPERCENT,
  84            "::?": TokenType.DCOLONQMARK,
  85            "RECORD": TokenType.STRUCT,
  86        }
  87
  88    class Parser(MySQL.Parser):
  89        FUNCTIONS = {
  90            **MySQL.Parser.FUNCTIONS,
  91            "TO_DATE": build_formatted_time(exp.TsOrDsToDate, "singlestore"),
  92            "TO_TIMESTAMP": build_formatted_time(exp.StrToTime, "singlestore"),
  93            "TO_CHAR": build_formatted_time(exp.ToChar, "singlestore"),
  94            "STR_TO_DATE": build_formatted_time(exp.StrToDate, "mysql"),
  95            "DATE_FORMAT": build_formatted_time(exp.TimeToStr, "mysql"),
  96            # The first argument of following functions is converted to TIME(6)
  97            # This is needed because exp.TimeToStr is converted to DATE_FORMAT
  98            # which interprets the first argument as DATETIME and fails to parse
  99            # string literals like '12:05:47' without a date part.
 100            "TIME_FORMAT": lambda args: exp.TimeToStr(
 101                this=cast_to_time6(seq_get(args, 0)),
 102                format=MySQL.format_time(seq_get(args, 1)),
 103            ),
 104            "HOUR": lambda args: exp.cast(
 105                exp.TimeToStr(
 106                    this=cast_to_time6(seq_get(args, 0)),
 107                    format=MySQL.format_time(exp.Literal.string("%k")),
 108                ),
 109                DataType.Type.INT,
 110            ),
 111            "MICROSECOND": lambda args: exp.cast(
 112                exp.TimeToStr(
 113                    this=cast_to_time6(seq_get(args, 0)),
 114                    format=MySQL.format_time(exp.Literal.string("%f")),
 115                ),
 116                DataType.Type.INT,
 117            ),
 118            "SECOND": lambda args: exp.cast(
 119                exp.TimeToStr(
 120                    this=cast_to_time6(seq_get(args, 0)),
 121                    format=MySQL.format_time(exp.Literal.string("%s")),
 122                ),
 123                DataType.Type.INT,
 124            ),
 125            "MINUTE": lambda args: exp.cast(
 126                exp.TimeToStr(
 127                    this=cast_to_time6(seq_get(args, 0)),
 128                    format=MySQL.format_time(exp.Literal.string("%i")),
 129                ),
 130                DataType.Type.INT,
 131            ),
 132            "MONTHNAME": lambda args: exp.TimeToStr(
 133                this=seq_get(args, 0),
 134                format=MySQL.format_time(exp.Literal.string("%M")),
 135            ),
 136            "WEEKDAY": lambda args: exp.paren(exp.DayOfWeek(this=seq_get(args, 0)) + 5, copy=False)
 137            % 7,
 138            "UNIX_TIMESTAMP": exp.StrToUnix.from_arg_list,
 139            "FROM_UNIXTIME": build_formatted_time(exp.UnixToTime, "mysql"),
 140            "TIME_BUCKET": lambda args: exp.DateBin(
 141                this=seq_get(args, 0),
 142                expression=seq_get(args, 1),
 143                origin=seq_get(args, 2),
 144            ),
 145            "BSON_EXTRACT_BSON": build_json_extract_path(exp.JSONBExtract),
 146            "BSON_EXTRACT_STRING": build_json_extract_path(
 147                exp.JSONBExtractScalar, json_type="STRING"
 148            ),
 149            "BSON_EXTRACT_DOUBLE": build_json_extract_path(
 150                exp.JSONBExtractScalar, json_type="DOUBLE"
 151            ),
 152            "BSON_EXTRACT_BIGINT": build_json_extract_path(
 153                exp.JSONBExtractScalar, json_type="BIGINT"
 154            ),
 155            "JSON_EXTRACT_JSON": build_json_extract_path(exp.JSONExtract),
 156            "JSON_EXTRACT_STRING": build_json_extract_path(
 157                exp.JSONExtractScalar, json_type="STRING"
 158            ),
 159            "JSON_EXTRACT_DOUBLE": build_json_extract_path(
 160                exp.JSONExtractScalar, json_type="DOUBLE"
 161            ),
 162            "JSON_EXTRACT_BIGINT": build_json_extract_path(
 163                exp.JSONExtractScalar, json_type="BIGINT"
 164            ),
 165            "JSON_ARRAY_CONTAINS_STRING": lambda args: exp.JSONArrayContains(
 166                this=seq_get(args, 1),
 167                expression=seq_get(args, 0),
 168                json_type="STRING",
 169            ),
 170            "JSON_ARRAY_CONTAINS_DOUBLE": lambda args: exp.JSONArrayContains(
 171                this=seq_get(args, 1),
 172                expression=seq_get(args, 0),
 173                json_type="DOUBLE",
 174            ),
 175            "JSON_ARRAY_CONTAINS_JSON": lambda args: exp.JSONArrayContains(
 176                this=seq_get(args, 1),
 177                expression=seq_get(args, 0),
 178                json_type="JSON",
 179            ),
 180            "JSON_KEYS": lambda args: exp.JSONKeys(
 181                this=seq_get(args, 0),
 182                expressions=args[1:],
 183            ),
 184            "JSON_PRETTY": exp.JSONFormat.from_arg_list,
 185            "JSON_BUILD_ARRAY": lambda args: exp.JSONArray(expressions=args),
 186            "JSON_BUILD_OBJECT": lambda args: exp.JSONObject(expressions=args),
 187            "DATE": exp.Date.from_arg_list,
 188            "DAYNAME": lambda args: exp.TimeToStr(
 189                this=seq_get(args, 0),
 190                format=MySQL.format_time(exp.Literal.string("%W")),
 191            ),
 192            "TIMESTAMPDIFF": lambda args: exp.TimestampDiff(
 193                this=seq_get(args, 2),
 194                expression=seq_get(args, 1),
 195                unit=seq_get(args, 0),
 196            ),
 197            "APPROX_COUNT_DISTINCT": exp.Hll.from_arg_list,
 198            "APPROX_PERCENTILE": lambda args, dialect: exp.ApproxQuantile(
 199                this=seq_get(args, 0),
 200                quantile=seq_get(args, 1),
 201                error_tolerance=seq_get(args, 2),
 202            ),
 203            "VARIANCE": exp.VariancePop.from_arg_list,
 204            "INSTR": exp.Contains.from_arg_list,
 205            "REGEXP_MATCH": lambda args: exp.RegexpExtractAll(
 206                this=seq_get(args, 0),
 207                expression=seq_get(args, 1),
 208                parameters=seq_get(args, 2),
 209            ),
 210            "REGEXP_SUBSTR": lambda args: exp.RegexpExtract(
 211                this=seq_get(args, 0),
 212                expression=seq_get(args, 1),
 213                position=seq_get(args, 2),
 214                occurrence=seq_get(args, 3),
 215                parameters=seq_get(args, 4),
 216            ),
 217            "REDUCE": lambda args: exp.Reduce(
 218                initial=seq_get(args, 0),
 219                this=seq_get(args, 1),
 220                merge=seq_get(args, 2),
 221            ),
 222        }
 223
 224        FUNCTION_PARSERS: t.Dict[str, t.Callable] = {
 225            **MySQL.Parser.FUNCTION_PARSERS,
 226            "JSON_AGG": lambda self: exp.JSONArrayAgg(
 227                this=self._parse_term(),
 228                order=self._parse_order(),
 229            ),
 230        }
 231
 232        NO_PAREN_FUNCTIONS = {
 233            **MySQL.Parser.NO_PAREN_FUNCTIONS,
 234            TokenType.UTC_DATE: exp.UtcDate,
 235            TokenType.UTC_TIME: exp.UtcTime,
 236            TokenType.UTC_TIMESTAMP: exp.UtcTimestamp,
 237        }
 238
 239        CAST_COLUMN_OPERATORS = {TokenType.COLON_GT, TokenType.NCOLON_GT}
 240
 241        COLUMN_OPERATORS = {
 242            **MySQL.Parser.COLUMN_OPERATORS,
 243            TokenType.COLON_GT: lambda self, this, to: self.expression(
 244                exp.Cast,
 245                this=this,
 246                to=to,
 247            ),
 248            TokenType.NCOLON_GT: lambda self, this, to: self.expression(
 249                exp.TryCast,
 250                this=this,
 251                to=to,
 252            ),
 253            TokenType.DCOLON: lambda self, this, path: build_json_extract_path(exp.JSONExtract)(
 254                [this, exp.Literal.string(path.name)]
 255            ),
 256            TokenType.DCOLONDOLLAR: lambda self, this, path: build_json_extract_path(
 257                exp.JSONExtractScalar, json_type="STRING"
 258            )([this, exp.Literal.string(path.name)]),
 259            TokenType.DCOLONPERCENT: lambda self, this, path: build_json_extract_path(
 260                exp.JSONExtractScalar, json_type="DOUBLE"
 261            )([this, exp.Literal.string(path.name)]),
 262            TokenType.DCOLONQMARK: lambda self, this, path: self.expression(
 263                exp.JSONExists,
 264                this=this,
 265                path=path.name,
 266                from_dcolonqmark=True,
 267            ),
 268        }
 269        COLUMN_OPERATORS.pop(TokenType.ARROW)
 270        COLUMN_OPERATORS.pop(TokenType.DARROW)
 271        COLUMN_OPERATORS.pop(TokenType.HASH_ARROW)
 272        COLUMN_OPERATORS.pop(TokenType.DHASH_ARROW)
 273        COLUMN_OPERATORS.pop(TokenType.PLACEHOLDER)
 274
 275        SHOW_PARSERS = {
 276            **MySQL.Parser.SHOW_PARSERS,
 277            "AGGREGATES": _show_parser("AGGREGATES"),
 278            "CDC EXTRACTOR POOL": _show_parser("CDC EXTRACTOR POOL"),
 279            "CREATE AGGREGATE": _show_parser("CREATE AGGREGATE", target=True),
 280            "CREATE PIPELINE": _show_parser("CREATE PIPELINE", target=True),
 281            "CREATE PROJECTION": _show_parser("CREATE PROJECTION", target=True),
 282            "DATABASE STATUS": _show_parser("DATABASE STATUS"),
 283            "DISTRIBUTED_PLANCACHE STATUS": _show_parser("DISTRIBUTED_PLANCACHE STATUS"),
 284            "FULLTEXT SERVICE METRICS LOCAL": _show_parser("FULLTEXT SERVICE METRICS LOCAL"),
 285            "FULLTEXT SERVICE METRICS FOR NODE": _show_parser(
 286                "FULLTEXT SERVICE METRICS FOR NODE", target=True
 287            ),
 288            "FULLTEXT SERVICE STATUS": _show_parser("FULLTEXT SERVICE STATUS"),
 289            "FUNCTIONS": _show_parser("FUNCTIONS"),
 290            "GROUPS": _show_parser("GROUPS"),
 291            "GROUPS FOR ROLE": _show_parser("GROUPS FOR ROLE", target=True),
 292            "GROUPS FOR USER": _show_parser("GROUPS FOR USER", target=True),
 293            "INDEXES": _show_parser("INDEX", target="FROM"),
 294            "KEYS": _show_parser("INDEX", target="FROM"),
 295            "LINKS": _show_parser("LINKS", target="ON"),
 296            "LOAD ERRORS": _show_parser("LOAD ERRORS"),
 297            "LOAD WARNINGS": _show_parser("LOAD WARNINGS"),
 298            "PARTITIONS": _show_parser("PARTITIONS", target="ON"),
 299            "PIPELINES": _show_parser("PIPELINES"),
 300            "PLAN": _show_parser("PLAN", target=True),
 301            "PLANCACHE": _show_parser("PLANCACHE"),
 302            "PROCEDURES": _show_parser("PROCEDURES"),
 303            "PROJECTIONS": _show_parser("PROJECTIONS", target="ON TABLE"),
 304            "REPLICATION STATUS": _show_parser("REPLICATION STATUS"),
 305            "REPRODUCTION": _show_parser("REPRODUCTION"),
 306            "RESOURCE POOLS": _show_parser("RESOURCE POOLS"),
 307            "ROLES": _show_parser("ROLES"),
 308            "ROLES FOR USER": _show_parser("ROLES FOR USER", target=True),
 309            "ROLES FOR GROUP": _show_parser("ROLES FOR GROUP", target=True),
 310            "STATUS EXTENDED": _show_parser("STATUS EXTENDED"),
 311            "USERS": _show_parser("USERS"),
 312            "USERS FOR ROLE": _show_parser("USERS FOR ROLE", target=True),
 313            "USERS FOR GROUP": _show_parser("USERS FOR GROUP", target=True),
 314        }
 315
 316        ALTER_PARSERS = {
 317            **MySQL.Parser.ALTER_PARSERS,
 318            "CHANGE": lambda self: self.expression(
 319                exp.RenameColumn, this=self._parse_column(), to=self._parse_column()
 320            ),
 321        }
 322
 323        def _parse_vector_expressions(
 324            self, expressions: t.List[exp.Expression]
 325        ) -> t.List[exp.Expression]:
 326            type_name = expressions[1].name.upper()
 327            if type_name in self.dialect.VECTOR_TYPE_ALIASES:
 328                type_name = self.dialect.VECTOR_TYPE_ALIASES[type_name]
 329
 330            return [exp.DataType.build(type_name, dialect=self.dialect), expressions[0]]
 331
 332    class Generator(MySQL.Generator):
 333        SUPPORTS_UESCAPE = False
 334        NULL_ORDERING_SUPPORTED = True
 335        MATCH_AGAINST_TABLE_PREFIX = "TABLE "
 336        STRUCT_DELIMITER = ("(", ")")
 337
 338        @staticmethod
 339        def _unicode_substitute(m: re.Match[str]) -> str:
 340            # Interpret the number as hex and convert it to the Unicode string
 341            return chr(int(m.group(1), 16))
 342
 343        UNICODE_SUBSTITUTE: t.Optional[t.Callable[[re.Match[str]], str]] = _unicode_substitute
 344
 345        SUPPORTED_JSON_PATH_PARTS = {
 346            exp.JSONPathKey,
 347            exp.JSONPathRoot,
 348            exp.JSONPathSubscript,
 349        }
 350
 351        TRANSFORMS = {
 352            **MySQL.Generator.TRANSFORMS,
 353            exp.TsOrDsToDate: lambda self, e: self.func("TO_DATE", e.this, self.format_time(e))
 354            if e.args.get("format")
 355            else self.func("DATE", e.this),
 356            exp.StrToTime: lambda self, e: self.func("TO_TIMESTAMP", e.this, self.format_time(e)),
 357            exp.ToChar: lambda self, e: self.func("TO_CHAR", e.this, self.format_time(e)),
 358            exp.StrToDate: lambda self, e: self.func(
 359                "STR_TO_DATE",
 360                e.this,
 361                self.format_time(
 362                    e,
 363                    inverse_time_mapping=MySQL.INVERSE_TIME_MAPPING,
 364                    inverse_time_trie=MySQL.INVERSE_TIME_TRIE,
 365                ),
 366            ),
 367            exp.TimeToStr: lambda self, e: self.func(
 368                "DATE_FORMAT",
 369                e.this,
 370                self.format_time(
 371                    e,
 372                    inverse_time_mapping=MySQL.INVERSE_TIME_MAPPING,
 373                    inverse_time_trie=MySQL.INVERSE_TIME_TRIE,
 374                ),
 375            ),
 376            exp.Date: unsupported_args("zone", "expressions")(rename_func("DATE")),
 377            exp.Cast: unsupported_args("format", "action", "default")(
 378                lambda self, e: f"{self.sql(e, 'this')} :> {self.sql(e, 'to')}"
 379            ),
 380            exp.TryCast: unsupported_args("format", "action", "default")(
 381                lambda self, e: f"{self.sql(e, 'this')} !:> {self.sql(e, 'to')}"
 382            ),
 383            exp.CastToStrType: lambda self, e: self.sql(
 384                exp.cast(e.this, DataType.build(e.args["to"].name))
 385            ),
 386            exp.StrToUnix: unsupported_args("format")(rename_func("UNIX_TIMESTAMP")),
 387            exp.TimeToUnix: rename_func("UNIX_TIMESTAMP"),
 388            exp.TimeStrToUnix: rename_func("UNIX_TIMESTAMP"),
 389            exp.UnixSeconds: rename_func("UNIX_TIMESTAMP"),
 390            exp.UnixToStr: lambda self, e: self.func(
 391                "FROM_UNIXTIME",
 392                e.this,
 393                self.format_time(
 394                    e,
 395                    inverse_time_mapping=MySQL.INVERSE_TIME_MAPPING,
 396                    inverse_time_trie=MySQL.INVERSE_TIME_TRIE,
 397                ),
 398            ),
 399            exp.UnixToTime: unsupported_args("scale", "zone", "hours", "minutes")(
 400                lambda self, e: self.func(
 401                    "FROM_UNIXTIME",
 402                    e.this,
 403                    self.format_time(
 404                        e,
 405                        inverse_time_mapping=MySQL.INVERSE_TIME_MAPPING,
 406                        inverse_time_trie=MySQL.INVERSE_TIME_TRIE,
 407                    ),
 408                ),
 409            ),
 410            exp.UnixToTimeStr: lambda self, e: f"FROM_UNIXTIME({self.sql(e, 'this')}) :> TEXT",
 411            exp.DateBin: unsupported_args("unit", "zone")(
 412                lambda self, e: self.func("TIME_BUCKET", e.this, e.expression, e.args.get("origin"))
 413            ),
 414            exp.TimeStrToDate: lambda self, e: self.sql(exp.cast(e.this, exp.DataType.Type.DATE)),
 415            exp.FromTimeZone: lambda self, e: self.func(
 416                "CONVERT_TZ", e.this, e.args.get("zone"), "'UTC'"
 417            ),
 418            exp.DiToDate: lambda self,
 419            e: f"STR_TO_DATE({self.sql(e, 'this')}, {SingleStore.DATEINT_FORMAT})",
 420            exp.DateToDi: lambda self,
 421            e: f"(DATE_FORMAT({self.sql(e, 'this')}, {SingleStore.DATEINT_FORMAT}) :> INT)",
 422            exp.TsOrDiToDi: lambda self,
 423            e: f"(DATE_FORMAT({self.sql(e, 'this')}, {SingleStore.DATEINT_FORMAT}) :> INT)",
 424            exp.Time: unsupported_args("zone")(lambda self, e: f"{self.sql(e, 'this')} :> TIME"),
 425            exp.DatetimeAdd: _remove_ts_or_ds_to_date(date_add_sql("ADD")),
 426            exp.DatetimeTrunc: unsupported_args("zone")(timestamptrunc_sql()),
 427            exp.DatetimeSub: date_add_interval_sql("DATE", "SUB"),
 428            exp.DatetimeDiff: timestampdiff_sql,
 429            exp.DateTrunc: unsupported_args("zone")(timestamptrunc_sql()),
 430            exp.DateDiff: unsupported_args("zone")(
 431                lambda self, e: timestampdiff_sql(self, e)
 432                if e.unit is not None
 433                else self.func("DATEDIFF", e.this, e.expression)
 434            ),
 435            exp.TsOrDsDiff: lambda self, e: timestampdiff_sql(self, e)
 436            if e.unit is not None
 437            else self.func("DATEDIFF", e.this, e.expression),
 438            exp.TimestampTrunc: unsupported_args("zone")(timestamptrunc_sql()),
 439            exp.CurrentDatetime: lambda self, e: self.sql(
 440                cast_to_time6(
 441                    exp.CurrentTimestamp(this=exp.Literal.number(6)), exp.DataType.Type.DATETIME
 442                )
 443            ),
 444            exp.JSONExtract: unsupported_args(
 445                "only_json_types",
 446                "expressions",
 447                "variant_extract",
 448                "json_query",
 449                "option",
 450                "quote",
 451                "on_condition",
 452                "requires_json",
 453            )(json_extract_segments("JSON_EXTRACT_JSON")),
 454            exp.JSONBExtract: json_extract_segments("BSON_EXTRACT_BSON"),
 455            exp.JSONPathKey: json_path_key_only_name,
 456            exp.JSONPathSubscript: lambda self, e: self.json_path_part(e.this),
 457            exp.JSONPathRoot: lambda *_: "",
 458            exp.JSONFormat: unsupported_args("options", "is_json")(rename_func("JSON_PRETTY")),
 459            exp.JSONArrayAgg: unsupported_args("null_handling", "return_type", "strict")(
 460                lambda self, e: self.func("JSON_AGG", e.this, suffix=f"{self.sql(e, 'order')})")
 461            ),
 462            exp.JSONArray: unsupported_args("null_handling", "return_type", "strict")(
 463                rename_func("JSON_BUILD_ARRAY")
 464            ),
 465            exp.JSONBExists: lambda self, e: self.func(
 466                "BSON_MATCH_ANY_EXISTS", e.this, e.args.get("path")
 467            ),
 468            exp.JSONExists: lambda self, e: (
 469                f"{self.sql(e.this)}::?{self.sql(e.args.get('path'))}"
 470                if e.args.get("from_dcolonqmark")
 471                else self.func("JSON_MATCH_ANY_EXISTS", e.this, e.args.get("path"))
 472            ),
 473            exp.JSONObject: unsupported_args(
 474                "null_handling", "unique_keys", "return_type", "encoding"
 475            )(rename_func("JSON_BUILD_OBJECT")),
 476            exp.DayOfWeekIso: lambda self, e: f"(({self.func('DAYOFWEEK', e.this)} % 7) + 1)",
 477            exp.DayOfMonth: rename_func("DAY"),
 478            exp.Hll: rename_func("APPROX_COUNT_DISTINCT"),
 479            exp.ApproxDistinct: rename_func("APPROX_COUNT_DISTINCT"),
 480            exp.CountIf: count_if_to_sum,
 481            exp.LogicalOr: lambda self, e: f"MAX(ABS({self.sql(e, 'this')}))",
 482            exp.LogicalAnd: lambda self, e: f"MIN(ABS({self.sql(e, 'this')}))",
 483            exp.ApproxQuantile: unsupported_args("accuracy", "weight")(
 484                lambda self, e: self.func(
 485                    "APPROX_PERCENTILE",
 486                    e.this,
 487                    e.args.get("quantile"),
 488                    e.args.get("error_tolerance"),
 489                )
 490            ),
 491            exp.Variance: rename_func("VAR_SAMP"),
 492            exp.VariancePop: rename_func("VAR_POP"),
 493            exp.Xor: bool_xor_sql,
 494            exp.Cbrt: lambda self, e: self.sql(
 495                exp.Pow(this=e.this, expression=exp.Literal.number(1) / exp.Literal.number(3))
 496            ),
 497            exp.RegexpLike: lambda self, e: self.binary(e, "RLIKE"),
 498            exp.Repeat: lambda self, e: self.func(
 499                "LPAD",
 500                exp.Literal.string(""),
 501                exp.Mul(this=self.func("LENGTH", e.this), expression=e.args.get("times")),
 502                e.this,
 503            ),
 504            exp.IsAscii: lambda self, e: f"({self.sql(e, 'this')} RLIKE '^[\x00-\x7f]*$')",
 505            exp.MD5Digest: lambda self, e: self.func("UNHEX", self.func("MD5", e.this)),
 506            exp.Contains: rename_func("INSTR"),
 507            exp.RegexpExtractAll: unsupported_args("position", "occurrence", "group")(
 508                lambda self, e: self.func(
 509                    "REGEXP_MATCH",
 510                    e.this,
 511                    e.expression,
 512                    e.args.get("parameters"),
 513                )
 514            ),
 515            exp.RegexpExtract: unsupported_args("group")(
 516                lambda self, e: self.func(
 517                    "REGEXP_SUBSTR",
 518                    e.this,
 519                    e.expression,
 520                    e.args.get("position"),
 521                    e.args.get("occurrence"),
 522                    e.args.get("parameters"),
 523                )
 524            ),
 525            exp.StartsWith: lambda self, e: self.func(
 526                "REGEXP_INSTR", e.this, self.func("CONCAT", exp.Literal.string("^"), e.expression)
 527            ),
 528            exp.FromBase: lambda self, e: self.func(
 529                "CONV", e.this, e.expression, exp.Literal.number(10)
 530            ),
 531            exp.RegexpILike: lambda self, e: self.binary(
 532                exp.RegexpLike(
 533                    this=exp.Lower(this=e.this),
 534                    expression=exp.Lower(this=e.expression),
 535                ),
 536                "RLIKE",
 537            ),
 538            exp.Stuff: lambda self, e: self.func(
 539                "CONCAT",
 540                self.func("SUBSTRING", e.this, exp.Literal.number(1), e.args.get("start") - 1),
 541                e.expression,
 542                self.func("SUBSTRING", e.this, e.args.get("start") + e.args.get("length")),
 543            ),
 544            exp.National: lambda self, e: self.national_sql(e, prefix=""),
 545            exp.Reduce: unsupported_args("finish")(
 546                lambda self, e: self.func(
 547                    "REDUCE", e.args.get("initial"), e.this, e.args.get("merge")
 548                )
 549            ),
 550            exp.MatchAgainst: unsupported_args("modifier")(
 551                lambda self, e: super().matchagainst_sql(e)
 552            ),
 553            exp.Show: unsupported_args(
 554                "history",
 555                "terse",
 556                "offset",
 557                "starts_with",
 558                "limit",
 559                "from_",
 560                "scope",
 561                "scope_kind",
 562                "mutex",
 563                "query",
 564                "channel",
 565                "log",
 566                "types",
 567                "privileges",
 568            )(lambda self, e: super().show_sql(e)),
 569            exp.Describe: unsupported_args(
 570                "style",
 571                "kind",
 572                "expressions",
 573                "partition",
 574                "format",
 575            )(lambda self, e: super().describe_sql(e)),
 576        }
 577        TRANSFORMS.pop(exp.JSONExtractScalar)
 578        TRANSFORMS.pop(exp.CurrentDate)
 579
 580        UNSUPPORTED_TYPES = {
 581            exp.DataType.Type.ARRAY,
 582            exp.DataType.Type.AGGREGATEFUNCTION,
 583            exp.DataType.Type.SIMPLEAGGREGATEFUNCTION,
 584            exp.DataType.Type.BIGSERIAL,
 585            exp.DataType.Type.BPCHAR,
 586            exp.DataType.Type.DATEMULTIRANGE,
 587            exp.DataType.Type.DATERANGE,
 588            exp.DataType.Type.DYNAMIC,
 589            exp.DataType.Type.HLLSKETCH,
 590            exp.DataType.Type.HSTORE,
 591            exp.DataType.Type.IMAGE,
 592            exp.DataType.Type.INET,
 593            exp.DataType.Type.INT128,
 594            exp.DataType.Type.INT256,
 595            exp.DataType.Type.INT4MULTIRANGE,
 596            exp.DataType.Type.INT4RANGE,
 597            exp.DataType.Type.INT8MULTIRANGE,
 598            exp.DataType.Type.INT8RANGE,
 599            exp.DataType.Type.INTERVAL,
 600            exp.DataType.Type.IPADDRESS,
 601            exp.DataType.Type.IPPREFIX,
 602            exp.DataType.Type.IPV4,
 603            exp.DataType.Type.IPV6,
 604            exp.DataType.Type.LIST,
 605            exp.DataType.Type.MAP,
 606            exp.DataType.Type.LOWCARDINALITY,
 607            exp.DataType.Type.MONEY,
 608            exp.DataType.Type.MULTILINESTRING,
 609            exp.DataType.Type.NAME,
 610            exp.DataType.Type.NESTED,
 611            exp.DataType.Type.NOTHING,
 612            exp.DataType.Type.NULL,
 613            exp.DataType.Type.NUMMULTIRANGE,
 614            exp.DataType.Type.NUMRANGE,
 615            exp.DataType.Type.OBJECT,
 616            exp.DataType.Type.RANGE,
 617            exp.DataType.Type.ROWVERSION,
 618            exp.DataType.Type.SERIAL,
 619            exp.DataType.Type.SMALLSERIAL,
 620            exp.DataType.Type.SMALLMONEY,
 621            exp.DataType.Type.SUPER,
 622            exp.DataType.Type.TIMETZ,
 623            exp.DataType.Type.TIMESTAMPNTZ,
 624            exp.DataType.Type.TIMESTAMPLTZ,
 625            exp.DataType.Type.TIMESTAMPTZ,
 626            exp.DataType.Type.TIMESTAMP_NS,
 627            exp.DataType.Type.TSMULTIRANGE,
 628            exp.DataType.Type.TSRANGE,
 629            exp.DataType.Type.TSTZMULTIRANGE,
 630            exp.DataType.Type.TSTZRANGE,
 631            exp.DataType.Type.UINT128,
 632            exp.DataType.Type.UINT256,
 633            exp.DataType.Type.UNION,
 634            exp.DataType.Type.UNKNOWN,
 635            exp.DataType.Type.USERDEFINED,
 636            exp.DataType.Type.UUID,
 637            exp.DataType.Type.VARIANT,
 638            exp.DataType.Type.XML,
 639            exp.DataType.Type.TDIGEST,
 640        }
 641
 642        TYPE_MAPPING = {
 643            **MySQL.Generator.TYPE_MAPPING,
 644            exp.DataType.Type.BIGDECIMAL: "DECIMAL",
 645            exp.DataType.Type.BIT: "BOOLEAN",
 646            exp.DataType.Type.DATE32: "DATE",
 647            exp.DataType.Type.DATETIME64: "DATETIME",
 648            exp.DataType.Type.DECIMAL32: "DECIMAL",
 649            exp.DataType.Type.DECIMAL64: "DECIMAL",
 650            exp.DataType.Type.DECIMAL128: "DECIMAL",
 651            exp.DataType.Type.DECIMAL256: "DECIMAL",
 652            exp.DataType.Type.ENUM8: "ENUM",
 653            exp.DataType.Type.ENUM16: "ENUM",
 654            exp.DataType.Type.FIXEDSTRING: "TEXT",
 655            exp.DataType.Type.GEOMETRY: "GEOGRAPHY",
 656            exp.DataType.Type.POINT: "GEOGRAPHYPOINT",
 657            exp.DataType.Type.RING: "GEOGRAPHY",
 658            exp.DataType.Type.LINESTRING: "GEOGRAPHY",
 659            exp.DataType.Type.POLYGON: "GEOGRAPHY",
 660            exp.DataType.Type.MULTIPOLYGON: "GEOGRAPHY",
 661            exp.DataType.Type.STRUCT: "RECORD",
 662            exp.DataType.Type.JSONB: "BSON",
 663            exp.DataType.Type.TIMESTAMP: "TIMESTAMP",
 664            exp.DataType.Type.TIMESTAMP_S: "TIMESTAMP",
 665            exp.DataType.Type.TIMESTAMP_MS: "TIMESTAMP(6)",
 666        }
 667
 668        # https://docs.singlestore.com/cloud/reference/sql-reference/restricted-keywords/list-of-restricted-keywords/
 669        RESERVED_KEYWORDS = {
 670            "abs",
 671            "absolute",
 672            "access",
 673            "account",
 674            "acos",
 675            "action",
 676            "add",
 677            "adddate",
 678            "addtime",
 679            "admin",
 680            "aes_decrypt",
 681            "aes_encrypt",
 682            "after",
 683            "against",
 684            "aggregate",
 685            "aggregates",
 686            "aggregator",
 687            "aggregator_id",
 688            "aggregator_plan_hash",
 689            "aggregators",
 690            "algorithm",
 691            "all",
 692            "also",
 693            "alter",
 694            "always",
 695            "analyse",
 696            "analyze",
 697            "and",
 698            "anti_join",
 699            "any",
 700            "any_value",
 701            "approx_count_distinct",
 702            "approx_count_distinct_accumulate",
 703            "approx_count_distinct_combine",
 704            "approx_count_distinct_estimate",
 705            "approx_geography_intersects",
 706            "approx_percentile",
 707            "arghistory",
 708            "arrange",
 709            "arrangement",
 710            "array",
 711            "as",
 712            "asc",
 713            "ascii",
 714            "asensitive",
 715            "asin",
 716            "asm",
 717            "assertion",
 718            "assignment",
 719            "ast",
 720            "asymmetric",
 721            "async",
 722            "at",
 723            "atan",
 724            "atan2",
 725            "attach",
 726            "attribute",
 727            "authorization",
 728            "auto",
 729            "auto_increment",
 730            "auto_reprovision",
 731            "autostats",
 732            "autostats_cardinality_mode",
 733            "autostats_enabled",
 734            "autostats_histogram_mode",
 735            "autostats_sampling",
 736            "availability",
 737            "avg",
 738            "avg_row_length",
 739            "avro",
 740            "azure",
 741            "background",
 742            "_background_threads_for_cleanup",
 743            "backup",
 744            "backup_history",
 745            "backup_id",
 746            "backward",
 747            "batch",
 748            "batches",
 749            "batch_interval",
 750            "_batch_size_limit",
 751            "before",
 752            "begin",
 753            "between",
 754            "bigint",
 755            "bin",
 756            "binary",
 757            "_binary",
 758            "bit",
 759            "bit_and",
 760            "bit_count",
 761            "bit_or",
 762            "bit_xor",
 763            "blob",
 764            "bool",
 765            "boolean",
 766            "bootstrap",
 767            "both",
 768            "_bt",
 769            "btree",
 770            "bucket_count",
 771            "by",
 772            "byte",
 773            "byte_length",
 774            "cache",
 775            "call",
 776            "call_for_pipeline",
 777            "called",
 778            "capture",
 779            "cascade",
 780            "cascaded",
 781            "case",
 782            "cast",
 783            "catalog",
 784            "ceil",
 785            "ceiling",
 786            "chain",
 787            "change",
 788            "char",
 789            "character",
 790            "characteristics",
 791            "character_length",
 792            "char_length",
 793            "charset",
 794            "check",
 795            "checkpoint",
 796            "_check_can_connect",
 797            "_check_consistency",
 798            "checksum",
 799            "_checksum",
 800            "class",
 801            "clear",
 802            "client",
 803            "client_found_rows",
 804            "close",
 805            "cluster",
 806            "clustered",
 807            "cnf",
 808            "coalesce",
 809            "coercibility",
 810            "collate",
 811            "collation",
 812            "collect",
 813            "column",
 814            "columnar",
 815            "columns",
 816            "columnstore",
 817            "columnstore_segment_rows",
 818            "comment",
 819            "comments",
 820            "commit",
 821            "committed",
 822            "_commit_log_tail",
 823            "committed",
 824            "compact",
 825            "compile",
 826            "compressed",
 827            "compression",
 828            "concat",
 829            "concat_ws",
 830            "concurrent",
 831            "concurrently",
 832            "condition",
 833            "configuration",
 834            "connection",
 835            "connection_id",
 836            "connections",
 837            "config",
 838            "constraint",
 839            "constraints",
 840            "content",
 841            "continue",
 842            "_continue_replay",
 843            "conv",
 844            "conversion",
 845            "convert",
 846            "convert_tz",
 847            "copy",
 848            "_core",
 849            "cos",
 850            "cost",
 851            "cot",
 852            "count",
 853            "create",
 854            "credentials",
 855            "cross",
 856            "cube",
 857            "csv",
 858            "cume_dist",
 859            "curdate",
 860            "current",
 861            "current_catalog",
 862            "current_date",
 863            "current_role",
 864            "current_schema",
 865            "current_security_groups",
 866            "current_security_roles",
 867            "current_time",
 868            "current_timestamp",
 869            "current_user",
 870            "cursor",
 871            "curtime",
 872            "cycle",
 873            "data",
 874            "database",
 875            "databases",
 876            "date",
 877            "date_add",
 878            "datediff",
 879            "date_format",
 880            "date_sub",
 881            "date_trunc",
 882            "datetime",
 883            "day",
 884            "day_hour",
 885            "day_microsecond",
 886            "day_minute",
 887            "dayname",
 888            "dayofmonth",
 889            "dayofweek",
 890            "dayofyear",
 891            "day_second",
 892            "deallocate",
 893            "dec",
 894            "decimal",
 895            "declare",
 896            "decode",
 897            "default",
 898            "defaults",
 899            "deferrable",
 900            "deferred",
 901            "defined",
 902            "definer",
 903            "degrees",
 904            "delayed",
 905            "delay_key_write",
 906            "delete",
 907            "delimiter",
 908            "delimiters",
 909            "dense_rank",
 910            "desc",
 911            "describe",
 912            "detach",
 913            "deterministic",
 914            "dictionary",
 915            "differential",
 916            "directory",
 917            "disable",
 918            "discard",
 919            "_disconnect",
 920            "disk",
 921            "distinct",
 922            "distinctrow",
 923            "distributed_joins",
 924            "div",
 925            "do",
 926            "document",
 927            "domain",
 928            "dot_product",
 929            "double",
 930            "drop",
 931            "_drop_profile",
 932            "dual",
 933            "dump",
 934            "duplicate",
 935            "dynamic",
 936            "earliest",
 937            "each",
 938            "echo",
 939            "election",
 940            "else",
 941            "elseif",
 942            "elt",
 943            "enable",
 944            "enclosed",
 945            "encoding",
 946            "encrypted",
 947            "end",
 948            "engine",
 949            "engines",
 950            "enum",
 951            "errors",
 952            "escape",
 953            "escaped",
 954            "estimate",
 955            "euclidean_distance",
 956            "event",
 957            "events",
 958            "except",
 959            "exclude",
 960            "excluding",
 961            "exclusive",
 962            "execute",
 963            "exists",
 964            "exit",
 965            "exp",
 966            "explain",
 967            "extended",
 968            "extension",
 969            "external",
 970            "external_host",
 971            "external_port",
 972            "extract",
 973            "extractor",
 974            "extractors",
 975            "extra_join",
 976            "_failover",
 977            "failed_login_attempts",
 978            "failure",
 979            "false",
 980            "family",
 981            "fault",
 982            "fetch",
 983            "field",
 984            "fields",
 985            "file",
 986            "files",
 987            "fill",
 988            "first",
 989            "first_value",
 990            "fix_alter",
 991            "fixed",
 992            "float",
 993            "float4",
 994            "float8",
 995            "floor",
 996            "flush",
 997            "following",
 998            "for",
 999            "force",
1000            "force_compiled_mode",
1001            "force_interpreter_mode",
1002            "foreground",
1003            "foreign",
1004            "format",
1005            "forward",
1006            "found_rows",
1007            "freeze",
1008            "from",
1009            "from_base64",
1010            "from_days",
1011            "from_unixtime",
1012            "fs",
1013            "_fsync",
1014            "full",
1015            "fulltext",
1016            "function",
1017            "functions",
1018            "gc",
1019            "gcs",
1020            "get_format",
1021            "_gc",
1022            "_gcx",
1023            "generate",
1024            "geography",
1025            "geography_area",
1026            "geography_contains",
1027            "geography_distance",
1028            "geography_intersects",
1029            "geography_latitude",
1030            "geography_length",
1031            "geography_longitude",
1032            "geographypoint",
1033            "geography_point",
1034            "geography_within_distance",
1035            "geometry",
1036            "geometry_area",
1037            "geometry_contains",
1038            "geometry_distance",
1039            "geometry_filter",
1040            "geometry_intersects",
1041            "geometry_length",
1042            "geometrypoint",
1043            "geometry_point",
1044            "geometry_within_distance",
1045            "geometry_x",
1046            "geometry_y",
1047            "global",
1048            "_global_version_timestamp",
1049            "grant",
1050            "granted",
1051            "grants",
1052            "greatest",
1053            "group",
1054            "grouping",
1055            "groups",
1056            "group_concat",
1057            "gzip",
1058            "handle",
1059            "handler",
1060            "hard_cpu_limit_percentage",
1061            "hash",
1062            "has_temp_tables",
1063            "having",
1064            "hdfs",
1065            "header",
1066            "heartbeat_no_logging",
1067            "hex",
1068            "highlight",
1069            "high_priority",
1070            "hold",
1071            "holding",
1072            "host",
1073            "hosts",
1074            "hour",
1075            "hour_microsecond",
1076            "hour_minute",
1077            "hour_second",
1078            "identified",
1079            "identity",
1080            "if",
1081            "ifnull",
1082            "ignore",
1083            "ilike",
1084            "immediate",
1085            "immutable",
1086            "implicit",
1087            "import",
1088            "in",
1089            "including",
1090            "increment",
1091            "incremental",
1092            "index",
1093            "indexes",
1094            "inet_aton",
1095            "inet_ntoa",
1096            "inet6_aton",
1097            "inet6_ntoa",
1098            "infile",
1099            "inherit",
1100            "inherits",
1101            "_init_profile",
1102            "init",
1103            "initcap",
1104            "initialize",
1105            "initially",
1106            "inject",
1107            "inline",
1108            "inner",
1109            "inout",
1110            "input",
1111            "insensitive",
1112            "insert",
1113            "insert_method",
1114            "instance",
1115            "instead",
1116            "instr",
1117            "int",
1118            "int1",
1119            "int2",
1120            "int3",
1121            "int4",
1122            "int8",
1123            "integer",
1124            "_internal_dynamic_typecast",
1125            "interpreter_mode",
1126            "intersect",
1127            "interval",
1128            "into",
1129            "invoker",
1130            "is",
1131            "isnull",
1132            "isolation",
1133            "iterate",
1134            "join",
1135            "json",
1136            "json_agg",
1137            "json_array_contains_double",
1138            "json_array_contains_json",
1139            "json_array_contains_string",
1140            "json_array_push_double",
1141            "json_array_push_json",
1142            "json_array_push_string",
1143            "json_delete_key",
1144            "json_extract_double",
1145            "json_extract_json",
1146            "json_extract_string",
1147            "json_extract_bigint",
1148            "json_get_type",
1149            "json_length",
1150            "json_set_double",
1151            "json_set_json",
1152            "json_set_string",
1153            "json_splice_double",
1154            "json_splice_json",
1155            "json_splice_string",
1156            "kafka",
1157            "key",
1158            "key_block_size",
1159            "keys",
1160            "kill",
1161            "killall",
1162            "label",
1163            "lag",
1164            "language",
1165            "large",
1166            "last",
1167            "last_day",
1168            "last_insert_id",
1169            "last_value",
1170            "lateral",
1171            "latest",
1172            "lc_collate",
1173            "lc_ctype",
1174            "lcase",
1175            "lead",
1176            "leading",
1177            "leaf",
1178            "leakproof",
1179            "least",
1180            "leave",
1181            "leaves",
1182            "left",
1183            "length",
1184            "level",
1185            "license",
1186            "like",
1187            "limit",
1188            "lines",
1189            "listen",
1190            "llvm",
1191            "ln",
1192            "load",
1193            "loaddata_where",
1194            "_load",
1195            "local",
1196            "localtime",
1197            "localtimestamp",
1198            "locate",
1199            "location",
1200            "lock",
1201            "log",
1202            "log10",
1203            "log2",
1204            "long",
1205            "longblob",
1206            "longtext",
1207            "loop",
1208            "lower",
1209            "low_priority",
1210            "lpad",
1211            "_ls",
1212            "ltrim",
1213            "lz4",
1214            "management",
1215            "_management_thread",
1216            "mapping",
1217            "master",
1218            "match",
1219            "materialized",
1220            "max",
1221            "maxvalue",
1222            "max_concurrency",
1223            "max_errors",
1224            "max_partitions_per_batch",
1225            "max_queue_depth",
1226            "max_retries_per_batch_partition",
1227            "max_rows",
1228            "mbc",
1229            "md5",
1230            "mpl",
1231            "median",
1232            "mediumblob",
1233            "mediumint",
1234            "mediumtext",
1235            "member",
1236            "memory",
1237            "memory_percentage",
1238            "_memsql_table_id_lookup",
1239            "memsql",
1240            "memsql_deserialize",
1241            "memsql_imitating_kafka",
1242            "memsql_serialize",
1243            "merge",
1244            "metadata",
1245            "microsecond",
1246            "middleint",
1247            "min",
1248            "min_rows",
1249            "minus",
1250            "minute",
1251            "minute_microsecond",
1252            "minute_second",
1253            "minvalue",
1254            "mod",
1255            "mode",
1256            "model",
1257            "modifies",
1258            "modify",
1259            "month",
1260            "monthname",
1261            "months_between",
1262            "move",
1263            "mpl",
1264            "names",
1265            "named",
1266            "namespace",
1267            "national",
1268            "natural",
1269            "nchar",
1270            "next",
1271            "no",
1272            "node",
1273            "none",
1274            "no_query_rewrite",
1275            "noparam",
1276            "not",
1277            "nothing",
1278            "notify",
1279            "now",
1280            "nowait",
1281            "no_write_to_binlog",
1282            "no_query_rewrite",
1283            "norely",
1284            "nth_value",
1285            "ntile",
1286            "null",
1287            "nullcols",
1288            "nullif",
1289            "nulls",
1290            "numeric",
1291            "nvarchar",
1292            "object",
1293            "octet_length",
1294            "of",
1295            "off",
1296            "offline",
1297            "offset",
1298            "offsets",
1299            "oids",
1300            "on",
1301            "online",
1302            "only",
1303            "open",
1304            "operator",
1305            "optimization",
1306            "optimize",
1307            "optimizer",
1308            "optimizer_state",
1309            "option",
1310            "options",
1311            "optionally",
1312            "or",
1313            "order",
1314            "ordered_serialize",
1315            "orphan",
1316            "out",
1317            "out_of_order",
1318            "outer",
1319            "outfile",
1320            "over",
1321            "overlaps",
1322            "overlay",
1323            "owned",
1324            "owner",
1325            "pack_keys",
1326            "paired",
1327            "parser",
1328            "parquet",
1329            "partial",
1330            "partition",
1331            "partition_id",
1332            "partitioning",
1333            "partitions",
1334            "passing",
1335            "password",
1336            "password_lock_time",
1337            "parser",
1338            "pause",
1339            "_pause_replay",
1340            "percent_rank",
1341            "percentile_cont",
1342            "percentile_disc",
1343            "periodic",
1344            "persisted",
1345            "pi",
1346            "pipeline",
1347            "pipelines",
1348            "pivot",
1349            "placing",
1350            "plan",
1351            "plans",
1352            "plancache",
1353            "plugins",
1354            "pool",
1355            "pools",
1356            "port",
1357            "position",
1358            "pow",
1359            "power",
1360            "preceding",
1361            "precision",
1362            "prepare",
1363            "prepared",
1364            "preserve",
1365            "primary",
1366            "prior",
1367            "privileges",
1368            "procedural",
1369            "procedure",
1370            "procedures",
1371            "process",
1372            "processlist",
1373            "profile",
1374            "profiles",
1375            "program",
1376            "promote",
1377            "proxy",
1378            "purge",
1379            "quarter",
1380            "queries",
1381            "query",
1382            "query_timeout",
1383            "queue",
1384            "quote",
1385            "radians",
1386            "rand",
1387            "range",
1388            "rank",
1389            "read",
1390            "_read",
1391            "reads",
1392            "real",
1393            "reassign",
1394            "rebalance",
1395            "recheck",
1396            "record",
1397            "recursive",
1398            "redundancy",
1399            "redundant",
1400            "ref",
1401            "reference",
1402            "references",
1403            "refresh",
1404            "regexp",
1405            "reindex",
1406            "relative",
1407            "release",
1408            "reload",
1409            "rely",
1410            "remote",
1411            "remove",
1412            "rename",
1413            "repair",
1414            "_repair_table",
1415            "repeat",
1416            "repeatable",
1417            "_repl",
1418            "_reprovisioning",
1419            "replace",
1420            "replica",
1421            "replicate",
1422            "replicating",
1423            "replication",
1424            "durability",
1425            "require",
1426            "resource",
1427            "resource_pool",
1428            "reset",
1429            "restart",
1430            "restore",
1431            "restrict",
1432            "result",
1433            "_resurrect",
1434            "retry",
1435            "return",
1436            "returning",
1437            "returns",
1438            "reverse",
1439            "revoke",
1440            "rg_pool",
1441            "right",
1442            "right_anti_join",
1443            "right_semi_join",
1444            "right_straight_join",
1445            "rlike",
1446            "role",
1447            "roles",
1448            "rollback",
1449            "rollup",
1450            "round",
1451            "routine",
1452            "row",
1453            "row_count",
1454            "row_format",
1455            "row_number",
1456            "rows",
1457            "rowstore",
1458            "rule",
1459            "rpad",
1460            "_rpc",
1461            "rtrim",
1462            "running",
1463            "s3",
1464            "safe",
1465            "save",
1466            "savepoint",
1467            "scalar",
1468            "schema",
1469            "schemas",
1470            "schema_binding",
1471            "scroll",
1472            "search",
1473            "second",
1474            "second_microsecond",
1475            "sec_to_time",
1476            "security",
1477            "select",
1478            "semi_join",
1479            "_send_threads",
1480            "sensitive",
1481            "separator",
1482            "sequence",
1483            "sequences",
1484            "serial",
1485            "serializable",
1486            "series",
1487            "service_user",
1488            "server",
1489            "session",
1490            "session_user",
1491            "set",
1492            "setof",
1493            "security_lists_intersect",
1494            "sha",
1495            "sha1",
1496            "sha2",
1497            "shard",
1498            "sharded",
1499            "sharded_id",
1500            "share",
1501            "show",
1502            "shutdown",
1503            "sigmoid",
1504            "sign",
1505            "signal",
1506            "similar",
1507            "simple",
1508            "site",
1509            "signed",
1510            "sin",
1511            "skip",
1512            "skipped_batches",
1513            "sleep",
1514            "_sleep",
1515            "smallint",
1516            "snapshot",
1517            "_snapshot",
1518            "_snapshots",
1519            "soft_cpu_limit_percentage",
1520            "some",
1521            "soname",
1522            "sparse",
1523            "spatial",
1524            "spatial_check_index",
1525            "specific",
1526            "split",
1527            "sql",
1528            "sql_big_result",
1529            "sql_buffer_result",
1530            "sql_cache",
1531            "sql_calc_found_rows",
1532            "sqlexception",
1533            "sql_mode",
1534            "sql_no_cache",
1535            "sql_no_logging",
1536            "sql_small_result",
1537            "sqlstate",
1538            "sqlwarning",
1539            "sqrt",
1540            "ssl",
1541            "stable",
1542            "standalone",
1543            "start",
1544            "starting",
1545            "state",
1546            "statement",
1547            "statistics",
1548            "stats",
1549            "status",
1550            "std",
1551            "stddev",
1552            "stddev_pop",
1553            "stddev_samp",
1554            "stdin",
1555            "stdout",
1556            "stop",
1557            "storage",
1558            "str_to_date",
1559            "straight_join",
1560            "strict",
1561            "string",
1562            "strip",
1563            "subdate",
1564            "substr",
1565            "substring",
1566            "substring_index",
1567            "success",
1568            "sum",
1569            "super",
1570            "symmetric",
1571            "sync_snapshot",
1572            "sync",
1573            "_sync",
1574            "_sync2",
1575            "_sync_partitions",
1576            "_sync_snapshot",
1577            "synchronize",
1578            "sysid",
1579            "system",
1580            "table",
1581            "table_checksum",
1582            "tables",
1583            "tablespace",
1584            "tags",
1585            "tan",
1586            "target_size",
1587            "task",
1588            "temp",
1589            "template",
1590            "temporary",
1591            "temptable",
1592            "_term_bump",
1593            "terminate",
1594            "terminated",
1595            "test",
1596            "text",
1597            "then",
1598            "time",
1599            "timediff",
1600            "time_bucket",
1601            "time_format",
1602            "timeout",
1603            "timestamp",
1604            "timestampadd",
1605            "timestampdiff",
1606            "timezone",
1607            "time_to_sec",
1608            "tinyblob",
1609            "tinyint",
1610            "tinytext",
1611            "to",
1612            "to_base64",
1613            "to_char",
1614            "to_date",
1615            "to_days",
1616            "to_json",
1617            "to_number",
1618            "to_seconds",
1619            "to_timestamp",
1620            "tracelogs",
1621            "traditional",
1622            "trailing",
1623            "transform",
1624            "transaction",
1625            "_transactions_experimental",
1626            "treat",
1627            "trigger",
1628            "triggers",
1629            "trim",
1630            "true",
1631            "trunc",
1632            "truncate",
1633            "trusted",
1634            "two_phase",
1635            "_twopcid",
1636            "type",
1637            "types",
1638            "ucase",
1639            "unbounded",
1640            "uncommitted",
1641            "undefined",
1642            "undo",
1643            "unencrypted",
1644            "unenforced",
1645            "unhex",
1646            "unhold",
1647            "unicode",
1648            "union",
1649            "unique",
1650            "_unittest",
1651            "unix_timestamp",
1652            "unknown",
1653            "unlisten",
1654            "_unload",
1655            "unlock",
1656            "unlogged",
1657            "unpivot",
1658            "unsigned",
1659            "until",
1660            "update",
1661            "upgrade",
1662            "upper",
1663            "usage",
1664            "use",
1665            "user",
1666            "users",
1667            "using",
1668            "utc_date",
1669            "utc_time",
1670            "utc_timestamp",
1671            "_utf8",
1672            "vacuum",
1673            "valid",
1674            "validate",
1675            "validator",
1676            "value",
1677            "values",
1678            "varbinary",
1679            "varchar",
1680            "varcharacter",
1681            "variables",
1682            "variadic",
1683            "variance",
1684            "var_pop",
1685            "var_samp",
1686            "varying",
1687            "vector_sub",
1688            "verbose",
1689            "version",
1690            "view",
1691            "void",
1692            "volatile",
1693            "voting",
1694            "wait",
1695            "_wake",
1696            "warnings",
1697            "week",
1698            "weekday",
1699            "weekofyear",
1700            "when",
1701            "where",
1702            "while",
1703            "whitespace",
1704            "window",
1705            "with",
1706            "without",
1707            "within",
1708            "_wm_heartbeat",
1709            "work",
1710            "workload",
1711            "wrapper",
1712            "write",
1713            "xact_id",
1714            "xor",
1715            "year",
1716            "year_month",
1717            "yes",
1718            "zerofill",
1719            "zone",
1720        }
1721
1722        def jsonextractscalar_sql(self, expression: exp.JSONExtractScalar) -> str:
1723            json_type = expression.args.get("json_type")
1724            func_name = "JSON_EXTRACT_JSON" if json_type is None else f"JSON_EXTRACT_{json_type}"
1725            return json_extract_segments(func_name)(self, expression)
1726
1727        def jsonbextractscalar_sql(self, expression: exp.JSONBExtractScalar) -> str:
1728            json_type = expression.args.get("json_type")
1729            func_name = "BSON_EXTRACT_BSON" if json_type is None else f"BSON_EXTRACT_{json_type}"
1730            return json_extract_segments(func_name)(self, expression)
1731
1732        def jsonextractarray_sql(self, expression: exp.JSONExtractArray) -> str:
1733            self.unsupported("Arrays are not supported in SingleStore")
1734            return self.function_fallback_sql(expression)
1735
1736        @unsupported_args("on_condition")
1737        def jsonvalue_sql(self, expression: exp.JSONValue) -> str:
1738            res: exp.Expression = exp.JSONExtractScalar(
1739                this=expression.this,
1740                expression=expression.args.get("path"),
1741                json_type="STRING",
1742            )
1743
1744            returning = expression.args.get("returning")
1745            if returning is not None:
1746                res = exp.Cast(this=res, to=returning)
1747
1748            return self.sql(res)
1749
1750        def all_sql(self, expression: exp.All) -> str:
1751            self.unsupported("ALL subquery predicate is not supported in SingleStore")
1752            return super().all_sql(expression)
1753
1754        def jsonarraycontains_sql(self, expression: exp.JSONArrayContains) -> str:
1755            json_type = expression.text("json_type").upper()
1756
1757            if json_type:
1758                return self.func(
1759                    f"JSON_ARRAY_CONTAINS_{json_type}", expression.expression, expression.this
1760                )
1761
1762            return self.func(
1763                "JSON_ARRAY_CONTAINS_JSON",
1764                expression.expression,
1765                self.func("TO_JSON", expression.this),
1766            )
1767
1768        @unsupported_args("kind", "values")
1769        def datatype_sql(self, expression: exp.DataType) -> str:
1770            if expression.args.get("nested") and not expression.is_type(exp.DataType.Type.STRUCT):
1771                self.unsupported(
1772                    f"Argument 'nested' is not supported for representation of '{expression.this.value}' in SingleStore"
1773                )
1774
1775            if expression.is_type(exp.DataType.Type.VARBINARY) and not expression.expressions:
1776                # `VARBINARY` must always have a size - if it doesn't, we always generate `BLOB`
1777                return "BLOB"
1778            if expression.is_type(
1779                exp.DataType.Type.DECIMAL32,
1780                exp.DataType.Type.DECIMAL64,
1781                exp.DataType.Type.DECIMAL128,
1782                exp.DataType.Type.DECIMAL256,
1783            ):
1784                scale = self.expressions(expression, flat=True)
1785
1786                if expression.is_type(exp.DataType.Type.DECIMAL32):
1787                    precision = "9"
1788                elif expression.is_type(exp.DataType.Type.DECIMAL64):
1789                    precision = "18"
1790                elif expression.is_type(exp.DataType.Type.DECIMAL128):
1791                    precision = "38"
1792                else:
1793                    # 65 is a maximum precision supported in SingleStore
1794                    precision = "65"
1795                if scale is not None:
1796                    return f"DECIMAL({precision}, {scale[0]})"
1797                else:
1798                    return f"DECIMAL({precision})"
1799            if expression.is_type(exp.DataType.Type.VECTOR):
1800                expressions = expression.expressions
1801                if len(expressions) == 2:
1802                    type_name = self.sql(expressions[0])
1803                    if type_name in self.dialect.INVERSE_VECTOR_TYPE_ALIASES:
1804                        type_name = self.dialect.INVERSE_VECTOR_TYPE_ALIASES[type_name]
1805
1806                    return f"VECTOR({self.sql(expressions[1])}, {type_name})"
1807
1808            return super().datatype_sql(expression)
1809
1810        def collate_sql(self, expression: exp.Collate) -> str:
1811            # SingleStore does not support setting a collation for column in the SELECT query,
1812            # so we cast column to a LONGTEXT type with specific collation
1813            return self.binary(expression, ":> LONGTEXT COLLATE")
1814
1815        def currentdate_sql(self, expression: exp.CurrentDate) -> str:
1816            timezone = expression.this
1817            if timezone:
1818                if isinstance(timezone, exp.Literal) and timezone.name.lower() == "utc":
1819                    return self.func("UTC_DATE")
1820                self.unsupported("CurrentDate with timezone is not supported in SingleStore")
1821
1822            return self.func("CURRENT_DATE")
1823
1824        def currenttime_sql(self, expression: exp.CurrentTime) -> str:
1825            arg = expression.this
1826            if arg:
1827                if isinstance(arg, exp.Literal) and arg.name.lower() == "utc":
1828                    return self.func("UTC_TIME")
1829                if isinstance(arg, exp.Literal) and arg.is_number:
1830                    return self.func("CURRENT_TIME", arg)
1831                self.unsupported("CurrentTime with timezone is not supported in SingleStore")
1832
1833            return self.func("CURRENT_TIME")
1834
1835        def currenttimestamp_sql(self, expression: exp.CurrentTimestamp) -> str:
1836            arg = expression.this
1837            if arg:
1838                if isinstance(arg, exp.Literal) and arg.name.lower() == "utc":
1839                    return self.func("UTC_TIMESTAMP")
1840                if isinstance(arg, exp.Literal) and arg.is_number:
1841                    return self.func("CURRENT_TIMESTAMP", arg)
1842                self.unsupported("CurrentTimestamp with timezone is not supported in SingleStore")
1843
1844            return self.func("CURRENT_TIMESTAMP")
1845
1846        def standardhash_sql(self, expression: exp.StandardHash) -> str:
1847            hash_function = expression.expression
1848            if hash_function is None:
1849                return self.func("SHA", expression.this)
1850            if isinstance(hash_function, exp.Literal):
1851                if hash_function.name.lower() == "sha":
1852                    return self.func("SHA", expression.this)
1853                if hash_function.name.lower() == "md5":
1854                    return self.func("MD5", expression.this)
1855
1856                self.unsupported(
1857                    f"{hash_function.this} hash method is not supported in SingleStore"
1858                )
1859                return self.func("SHA", expression.this)
1860
1861            self.unsupported("STANDARD_HASH function is not supported in SingleStore")
1862            return self.func("SHA", expression.this)
1863
1864        @unsupported_args("is_database", "exists", "cluster", "identity", "option", "partition")
1865        def truncatetable_sql(self, expression: exp.TruncateTable) -> str:
1866            statements = []
1867            for expression in expression.expressions:
1868                statements.append(f"TRUNCATE {self.sql(expression)}")
1869
1870            return "; ".join(statements)
1871
1872        @unsupported_args("exists")
1873        def renamecolumn_sql(self, expression: exp.RenameColumn) -> str:
1874            old_column = self.sql(expression, "this")
1875            new_column = self.sql(expression, "to")
1876            return f"CHANGE {old_column} {new_column}"
1877
1878        @unsupported_args("drop", "comment", "allow_null", "visible", "using")
1879        def altercolumn_sql(self, expression: exp.AlterColumn) -> str:
1880            alter = super().altercolumn_sql(expression)
1881
1882            collate = self.sql(expression, "collate")
1883            collate = f" COLLATE {collate}" if collate else ""
1884            return f"{alter}{collate}"
1885
1886        def computedcolumnconstraint_sql(self, expression: exp.ComputedColumnConstraint) -> str:
1887            this = self.sql(expression, "this")
1888            not_null = " NOT NULL" if expression.args.get("not_null") else ""
1889            type = self.sql(expression, "data_type") or "AUTO"
1890            return f"AS {this} PERSISTED {type}{not_null}"