sqlglot.generators.singlestore

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