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 withingroup_sql(self, expression: exp.WithinGroup) -> str:
1458        # SingleStore includes trailing NULLs in percentile calculations, so we sort them first
1459        if isinstance(expression.this, (exp.PercentileCont, exp.PercentileDisc)) and isinstance(
1460            expression.expression, exp.Order
1461        ):
1462            expression = expression.copy()
1463            for ordered in expression.expression.expressions:
1464                ordered.set("nulls_first", True)
1465
1466        return super().withingroup_sql(expression)
1467
1468    def all_sql(self, expression: exp.All) -> str:
1469        self.unsupported("ALL subquery predicate is not supported in SingleStore")
1470        return super().all_sql(expression)
1471
1472    def jsonarraycontains_sql(self, expression: exp.JSONArrayContains) -> str:
1473        json_type = expression.text("json_type").upper()
1474
1475        if json_type:
1476            return self.func(
1477                f"JSON_ARRAY_CONTAINS_{json_type}", expression.expression, expression.this
1478            )
1479
1480        return self.func(
1481            "JSON_ARRAY_CONTAINS_JSON",
1482            expression.expression,
1483            self.func("TO_JSON", expression.this),
1484        )
1485
1486    def datatype_sql(self, expression: exp.DataType) -> str:
1487        for arg_name in ("kind", "values"):
1488            if expression.args.get(arg_name):
1489                self.unsupported(f"DATATYPE does not support {arg_name}")
1490        if expression.args.get("nested") and not expression.is_type(exp.DType.STRUCT):
1491            self.unsupported(
1492                f"Argument 'nested' is not supported for representation of '{expression.this.value}' in SingleStore"
1493            )
1494
1495        if expression.is_type(exp.DType.VARBINARY) and not expression.expressions:
1496            # `VARBINARY` must always have a size - if it doesn't, we always generate `BLOB`
1497            return "BLOB"
1498        if expression.is_type(
1499            exp.DType.DECIMAL32,
1500            exp.DType.DECIMAL64,
1501            exp.DType.DECIMAL128,
1502            exp.DType.DECIMAL256,
1503        ):
1504            scale = self.expressions(expression, flat=True)
1505
1506            if expression.is_type(exp.DType.DECIMAL32):
1507                precision = "9"
1508            elif expression.is_type(exp.DType.DECIMAL64):
1509                precision = "18"
1510            elif expression.is_type(exp.DType.DECIMAL128):
1511                precision = "38"
1512            else:
1513                # 65 is a maximum precision supported in SingleStore
1514                precision = "65"
1515            if scale is not None:
1516                return f"DECIMAL({precision}, {scale[0]})"
1517            else:
1518                return f"DECIMAL({precision})"
1519        if expression.is_type(exp.DType.VECTOR):
1520            expressions = expression.expressions
1521            if len(expressions) == 2:
1522                type_name = self.sql(expressions[0])
1523                if type_name in self.dialect.INVERSE_VECTOR_TYPE_ALIASES:
1524                    type_name = self.dialect.INVERSE_VECTOR_TYPE_ALIASES[type_name]
1525
1526                return f"VECTOR({self.sql(expressions[1])}, {type_name})"
1527
1528        return super().datatype_sql(expression)
1529
1530    def collate_sql(self, expression: exp.Collate) -> str:
1531        # SingleStore does not support setting a collation for column in the SELECT query,
1532        # so we cast column to a LONGTEXT type with specific collation. If the cast is
1533        # already there (e.g. when regenerating previously generated SQL), don't add
1534        # another one, so that generation stays idempotent.
1535        this = expression.this
1536        if isinstance(this, exp.Cast) and this.to.this == exp.DType.LONGTEXT:
1537            return self.binary(expression, "COLLATE")
1538        return self.binary(expression, ":> LONGTEXT COLLATE")
1539
1540    def currentdate_sql(self, expression: exp.CurrentDate) -> str:
1541        timezone = expression.this
1542        if timezone:
1543            if isinstance(timezone, exp.Literal) and timezone.name.lower() == "utc":
1544                return self.func("UTC_DATE")
1545            self.unsupported("CurrentDate with timezone is not supported in SingleStore")
1546
1547        return self.func("CURRENT_DATE")
1548
1549    def currenttime_sql(self, expression: exp.CurrentTime) -> str:
1550        arg = expression.this
1551        if arg:
1552            if isinstance(arg, exp.Literal) and arg.name.lower() == "utc":
1553                return self.func("UTC_TIME")
1554            if isinstance(arg, exp.Literal) and arg.is_number:
1555                return self.func("CURRENT_TIME", arg)
1556            self.unsupported("CurrentTime with timezone is not supported in SingleStore")
1557
1558        return self.func("CURRENT_TIME")
1559
1560    def currenttimestamp_sql(self, expression: exp.CurrentTimestamp) -> str:
1561        arg = expression.this
1562        if arg:
1563            if isinstance(arg, exp.Literal) and arg.name.lower() == "utc":
1564                return self.func("UTC_TIMESTAMP")
1565            if isinstance(arg, exp.Literal) and arg.is_number:
1566                return self.func("CURRENT_TIMESTAMP", arg)
1567            self.unsupported("CurrentTimestamp with timezone is not supported in SingleStore")
1568
1569        return self.func("CURRENT_TIMESTAMP")
1570
1571    def standardhash_sql(self, expression: exp.StandardHash) -> str:
1572        hash_function = expression.expression
1573        if hash_function is None:
1574            return self.func("SHA", expression.this)
1575        if isinstance(hash_function, exp.Literal):
1576            if hash_function.name.lower() == "sha":
1577                return self.func("SHA", expression.this)
1578            if hash_function.name.lower() == "md5":
1579                return self.func("MD5", expression.this)
1580
1581            self.unsupported(f"{hash_function.this} hash method is not supported in SingleStore")
1582            return self.func("SHA", expression.this)
1583
1584        self.unsupported("STANDARD_HASH function is not supported in SingleStore")
1585        return self.func("SHA", expression.this)
1586
1587    def truncatetable_sql(self, expression: exp.TruncateTable) -> str:
1588        for arg_name in ("is_database", "exists", "cluster", "identity", "option", "partition"):
1589            if expression.args.get(arg_name):
1590                self.unsupported(f"TRUNCATE TABLE does not support {arg_name}")
1591        statements = []
1592        for table in expression.expressions:
1593            statements.append(f"TRUNCATE {self.sql(table)}")
1594
1595        return "; ".join(statements)
1596
1597    def renamecolumn_sql(self, expression: exp.RenameColumn) -> str:
1598        if expression.args.get("exists"):
1599            self.unsupported("RENAME COLUMN does not support exists")
1600        old_column = self.sql(expression, "this")
1601        new_column = self.sql(expression, "to")
1602        return f"CHANGE {old_column} {new_column}"
1603
1604    def altercolumn_sql(self, expression: exp.AlterColumn) -> str:
1605        for arg_name in ("drop", "comment", "visible", "using"):
1606            if expression.args.get(arg_name):
1607                self.unsupported(f"ALTER COLUMN does not support {arg_name}")
1608        alter = super().altercolumn_sql(expression)
1609
1610        collate = self.sql(expression, "collate")
1611        collate = f" COLLATE {collate}" if collate else ""
1612        return f"{alter}{collate}"
1613
1614    def computedcolumnconstraint_sql(self, expression: exp.ComputedColumnConstraint) -> str:
1615        this = self.sql(expression, "this")
1616        not_null = " NOT NULL" if expression.args.get("not_null") else ""
1617        type = self.sql(expression, "data_type") or "AUTO"
1618        return f"AS {this} PERSISTED {type}{not_null}"