sqlglot 27.13.2__py3-none-any.whl → 27.15.0__py3-none-any.whl

sqlglot/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '27.13.2'
-__version_tuple__ = version_tuple = (27, 13, 2)
+__version__ = version = '27.15.0'
+__version_tuple__ = version_tuple = (27, 15, 0)
 
 __commit_id__ = commit_id = None

sqlglot/dialects/bigquery.py

@@ -859,10 +859,15 @@ class BigQuery(Dialect):
                 exp.JSONArray, expressions=self._parse_csv(self._parse_bitwise)
             ),
             "MAKE_INTERVAL": lambda self: self._parse_make_interval(),
-            "PREDICT": lambda self: self._parse_predict(),
+            "PREDICT": lambda self: self._parse_ml(exp.Predict),
+            "TRANSLATE": lambda self: self._parse_translate(),
             "FEATURES_AT_TIME": lambda self: self._parse_features_at_time(),
-            "GENERATE_EMBEDDING": lambda self: self._parse_generate_embedding(),
+            "GENERATE_EMBEDDING": lambda self: self._parse_ml(exp.GenerateEmbedding),
+            "GENERATE_TEXT_EMBEDDING": lambda self: self._parse_ml(
+                exp.GenerateEmbedding, is_text=True
+            ),
             "VECTOR_SEARCH": lambda self: self._parse_vector_search(),
+            "FORECAST": lambda self: self._parse_ml(exp.MLForecast),
         }
         FUNCTION_PARSERS.pop("TRIM")
 
@@ -892,8 +897,6 @@ class BigQuery(Dialect):
         RANGE_PARSERS = parser.Parser.RANGE_PARSERS.copy()
         RANGE_PARSERS.pop(TokenType.OVERLAPS)
 
-        NULL_TOKENS = {TokenType.NULL, TokenType.UNKNOWN}
-
         DASHED_TABLE_PART_FOLLOW_TOKENS = {TokenType.DOT, TokenType.L_PAREN, TokenType.R_PAREN}
 
         STATEMENT_PARSERS = {
@@ -1146,34 +1149,36 @@ class BigQuery(Dialect):
 
             return expr
 
-        def _parse_predict(self) -> exp.Predict:
+        def _parse_ml(self, expr_type: t.Type[E], **kwargs) -> E:
             self._match_text_seq("MODEL")
             this = self._parse_table()
 
             self._match(TokenType.COMMA)
             self._match_text_seq("TABLE")
 
-            return self.expression(
-                exp.Predict,
-                this=this,
-                expression=self._parse_table(),
-                params_struct=self._match(TokenType.COMMA) and self._parse_bitwise(),
+            # Certain functions like ML.FORECAST require a STRUCT argument but not a TABLE/SELECT one
+            expression = (
+                self._parse_table() if not self._match(TokenType.STRUCT, advance=False) else None
             )
 
-        def _parse_generate_embedding(self) -> exp.GenerateEmbedding:
-            self._match_text_seq("MODEL")
-            this = self._parse_table()
-
             self._match(TokenType.COMMA)
-            self._match_text_seq("TABLE")
 
             return self.expression(
-                exp.GenerateEmbedding,
+                expr_type,
                 this=this,
-                expression=self._parse_table(),
-                params_struct=self._match(TokenType.COMMA) and self._parse_bitwise(),
+                expression=expression,
+                params_struct=self._parse_bitwise(),
+                **kwargs,
             )
 
+        def _parse_translate(self) -> exp.Translate | exp.MLTranslate:
+            # Check if this is ML.TRANSLATE by looking at previous tokens
+            token = seq_get(self._tokens, self._index - 4)
+            if token and token.text.upper() == "ML":
+                return self._parse_ml(exp.MLTranslate)
+
+            return exp.Translate.from_arg_list(self._parse_function_args())
+
         def _parse_features_at_time(self) -> exp.FeaturesAtTime:
             self._match(TokenType.TABLE)
             this = self._parse_table()

sqlglot/dialects/clickhouse.py

@@ -189,6 +189,7 @@ def _map_sql(self: ClickHouse.Generator, expression: exp.Map | exp.VarMap) -> st
 
 
 class ClickHouse(Dialect):
+    INDEX_OFFSET = 1
     NORMALIZE_FUNCTIONS: bool | str = False
     NULL_ORDERING = "nulls_are_last"
     SUPPORTS_USER_DEFINED_TYPES = False

sqlglot/dialects/dialect.py

@@ -674,6 +674,7 @@ class Dialect(metaclass=_Dialect):
         exp.DataType.Type.BOOLEAN: {
             exp.Between,
             exp.Boolean,
+            exp.Contains,
             exp.EndsWith,
             exp.In,
             exp.LogicalAnd,
@@ -818,7 +819,6 @@ class Dialect(metaclass=_Dialect):
         exp.Cast: lambda self, e: self._annotate_with_type(e, e.args["to"]),
         exp.Case: lambda self, e: self._annotate_by_args(e, "default", "ifs"),
         exp.Coalesce: lambda self, e: self._annotate_by_args(e, "this", "expressions"),
-        exp.Contains: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BOOLEAN),
         exp.Count: lambda self, e: self._annotate_with_type(
             e, exp.DataType.Type.BIGINT if e.args.get("big_int") else exp.DataType.Type.INT
         ),

sqlglot/dialects/duckdb.py

@@ -365,6 +365,9 @@ class DuckDB(Dialect):
             "ANY_VALUE": lambda args: exp.IgnoreNulls(this=exp.AnyValue.from_arg_list(args)),
             "ARRAY_REVERSE_SORT": _build_sort_array_desc,
             "ARRAY_SORT": exp.SortArray.from_arg_list,
+            "BIT_AND": exp.BitwiseAndAgg.from_arg_list,
+            "BIT_OR": exp.BitwiseOrAgg.from_arg_list,
+            "BIT_XOR": exp.BitwiseXorAgg.from_arg_list,
             "DATEDIFF": _build_date_diff,
             "DATE_DIFF": _build_date_diff,
             "DATE_TRUNC": date_trunc_to_time,
@@ -649,7 +652,10 @@ class DuckDB(Dialect):
             exp.ArrayUniqueAgg: lambda self, e: self.func(
                 "LIST", exp.Distinct(expressions=[e.this])
             ),
+            exp.BitwiseAndAgg: rename_func("BIT_AND"),
+            exp.BitwiseOrAgg: rename_func("BIT_OR"),
             exp.BitwiseXor: rename_func("XOR"),
+            exp.BitwiseXorAgg: rename_func("BIT_XOR"),
             exp.CommentColumnConstraint: no_comment_column_constraint_sql,
             exp.CosineDistance: rename_func("LIST_COSINE_DISTANCE"),
             exp.CurrentDate: lambda *_: "CURRENT_DATE",
@@ -995,13 +1001,18 @@ class DuckDB(Dialect):
 
         def join_sql(self, expression: exp.Join) -> str:
             if (
-                expression.side == "LEFT"
+                not expression.args.get("using")
                 and not expression.args.get("on")
-                and isinstance(expression.this, exp.Unnest)
+                and not expression.method
+                and (expression.kind in ("", "INNER", "OUTER"))
             ):
-                # Some dialects support `LEFT JOIN UNNEST(...)` without an explicit ON clause
+                # Some dialects support `LEFT/INNER JOIN UNNEST(...)` without an explicit ON clause
                 # DuckDB doesn't, but we can just add a dummy ON clause that is always true
-                return super().join_sql(expression.on(exp.true()))
+                if isinstance(expression.this, exp.Unnest):
+                    return super().join_sql(expression.on(exp.true()))
+
+                expression.args.pop("side", None)
+                expression.args.pop("kind", None)
 
             return super().join_sql(expression)
 

sqlglot/dialects/fabric.py

@@ -125,7 +125,7 @@ class Fabric(TSQL):
             exp.DataType.Type.TIMESTAMPTZ: "DATETIME2",
             exp.DataType.Type.TINYINT: "SMALLINT",
             exp.DataType.Type.UTINYINT: "SMALLINT",
-            exp.DataType.Type.UUID: "VARBINARY(MAX)",
+            exp.DataType.Type.UUID: "UNIQUEIDENTIFIER",
             exp.DataType.Type.XML: "VARCHAR",
         }
 

sqlglot/dialects/hive.py

@@ -309,6 +309,7 @@ class Hive(Dialect):
         STRICT_CAST = False
         VALUES_FOLLOWED_BY_PAREN = False
         JOINS_HAVE_EQUAL_PRECEDENCE = True
+        ADD_JOIN_ON_TRUE = True
 
         FUNCTIONS = {
             **parser.Parser.FUNCTIONS,

sqlglot/dialects/mysql.py

@@ -191,10 +191,8 @@ class MySQL(Dialect):
 
         KEYWORDS = {
             **tokens.Tokenizer.KEYWORDS,
-            "CHARSET": TokenType.CHARACTER_SET,
-            # The DESCRIBE and EXPLAIN statements are synonyms.
-            # https://dev.mysql.com/doc/refman/8.4/en/explain.html
             "BLOB": TokenType.BLOB,
+            "CHARSET": TokenType.CHARACTER_SET,
             "DISTINCTROW": TokenType.DISTINCT,
             "EXPLAIN": TokenType.DESCRIBE,
             "FORCE": TokenType.FORCE,
@@ -204,17 +202,19 @@ class MySQL(Dialect):
             "LONGBLOB": TokenType.LONGBLOB,
             "LONGTEXT": TokenType.LONGTEXT,
             "MEDIUMBLOB": TokenType.MEDIUMBLOB,
-            "TINYBLOB": TokenType.TINYBLOB,
-            "TINYTEXT": TokenType.TINYTEXT,
-            "MEDIUMTEXT": TokenType.MEDIUMTEXT,
             "MEDIUMINT": TokenType.MEDIUMINT,
+            "MEDIUMTEXT": TokenType.MEDIUMTEXT,
             "MEMBER OF": TokenType.MEMBER_OF,
+            "MOD": TokenType.MOD,
             "SEPARATOR": TokenType.SEPARATOR,
             "SERIAL": TokenType.SERIAL,
-            "START": TokenType.BEGIN,
             "SIGNED": TokenType.BIGINT,
             "SIGNED INTEGER": TokenType.BIGINT,
+            "SOUNDS LIKE": TokenType.SOUNDS_LIKE,
+            "START": TokenType.BEGIN,
             "TIMESTAMP": TokenType.TIMESTAMPTZ,
+            "TINYBLOB": TokenType.TINYBLOB,
+            "TINYTEXT": TokenType.TINYTEXT,
             "UNLOCK TABLES": TokenType.COMMAND,
             "UNSIGNED": TokenType.UBIGINT,
             "UNSIGNED INTEGER": TokenType.UBIGINT,
@@ -271,6 +271,7 @@ class MySQL(Dialect):
         FUNC_TOKENS = {
             *parser.Parser.FUNC_TOKENS,
             TokenType.DATABASE,
+            TokenType.MOD,
             TokenType.SCHEMA,
             TokenType.VALUES,
         }
@@ -292,6 +293,11 @@ class MySQL(Dialect):
 
         RANGE_PARSERS = {
             **parser.Parser.RANGE_PARSERS,
+            TokenType.SOUNDS_LIKE: lambda self, this: self.expression(
+                exp.EQ,
+                this=self.expression(exp.Soundex, this=this),
+                expression=self.expression(exp.Soundex, this=self._parse_term()),
+            ),
             TokenType.MEMBER_OF: lambda self, this: self.expression(
                 exp.JSONArrayContains,
                 this=this,
@@ -359,6 +365,7 @@ class MySQL(Dialect):
                 exp.Anonymous, this="VALUES", expressions=[self._parse_id_var()]
             ),
             "JSON_VALUE": lambda self: self._parse_json_value(),
+            "SUBSTR": lambda self: self._parse_substring(),
         }
 
         STATEMENT_PARSERS = {
@@ -579,9 +586,11 @@ class MySQL(Dialect):
             full: t.Optional[bool] = None,
             global_: t.Optional[bool] = None,
         ) -> exp.Show:
+            json = self._match_text_seq("JSON")
+
             if target:
                 if isinstance(target, str):
-                    self._match_text_seq(target)
+                    self._match_text_seq(*target.split(" "))
                 target_id = self._parse_id_var()
             else:
                 target_id = None
@@ -618,6 +627,12 @@ class MySQL(Dialect):
             mutex = True if self._match_text_seq("MUTEX") else None
             mutex = False if self._match_text_seq("STATUS") else mutex
 
+            for_table = self._parse_id_var() if self._match_text_seq("FOR", "TABLE") else None
+            for_group = self._parse_string() if self._match_text_seq("FOR", "GROUP") else None
+            for_user = self._parse_string() if self._match_text_seq("FOR", "USER") else None
+            for_role = self._parse_string() if self._match_text_seq("FOR", "ROLE") else None
+            into_outfile = self._parse_string() if self._match_text_seq("INTO", "OUTFILE") else None
+
             return self.expression(
                 exp.Show,
                 this=this,
@@ -634,6 +649,12 @@ class MySQL(Dialect):
                 offset=offset,
                 limit=limit,
                 mutex=mutex,
+                for_table=for_table,
+                for_group=for_group,
+                for_user=for_user,
+                for_role=for_role,
+                into_outfile=into_outfile,
+                json=json,
                 **{"global": global_},  # type: ignore
             )
 
@@ -1200,6 +1221,10 @@ class MySQL(Dialect):
                 target = f" FROM{target}"
             elif expression.name == "GRANTS":
                 target = f" FOR{target}"
+            elif expression.name in ("LINKS", "PARTITIONS"):
+                target = f" ON{target}" if target else ""
+            elif expression.name == "PROJECTIONS":
+                target = f" ON TABLE{target}" if target else ""
 
             db = self._prefixed_sql("FROM", expression, "db")
 
@@ -1227,7 +1252,14 @@ class MySQL(Dialect):
             else:
                 mutex_or_status = ""
 
-            return f"SHOW{full}{global_}{this}{target}{types}{db}{query}{log}{position}{channel}{mutex_or_status}{like}{where}{offset}{limit}"
+            for_table = self._prefixed_sql("FOR TABLE", expression, "for_table")
+            for_group = self._prefixed_sql("FOR GROUP", expression, "for_group")
+            for_user = self._prefixed_sql("FOR USER", expression, "for_user")
+            for_role = self._prefixed_sql("FOR ROLE", expression, "for_role")
+            into_outfile = self._prefixed_sql("INTO OUTFILE", expression, "into_outfile")
+            json = " JSON" if expression.args.get("json") else ""
+
+            return f"SHOW{full}{global_}{this}{json}{target}{for_table}{types}{db}{query}{log}{position}{channel}{mutex_or_status}{like}{where}{offset}{limit}{for_group}{for_user}{for_role}{into_outfile}"
 
         def altercolumn_sql(self, expression: exp.AlterColumn) -> str:
             dtype = self.sql(expression, "dtype")

sqlglot/dialects/postgres.py

@@ -325,6 +325,9 @@ class Postgres(Dialect):
             "@@": TokenType.DAT,
             "@>": TokenType.AT_GT,
             "<@": TokenType.LT_AT,
+            "?&": TokenType.QMARK_AMP,
+            "?|": TokenType.QMARK_PIPE,
+            "#-": TokenType.HASH_DASH,
             "|/": TokenType.PIPE_SLASH,
             "||/": TokenType.DPIPE_SLASH,
             "BEGIN": TokenType.BEGIN,
@@ -386,6 +389,9 @@ class Postgres(Dialect):
 
         FUNCTIONS = {
             **parser.Parser.FUNCTIONS,
+            "BIT_AND": exp.BitwiseAndAgg.from_arg_list,
+            "BIT_OR": exp.BitwiseOrAgg.from_arg_list,
+            "BIT_XOR": exp.BitwiseXorAgg.from_arg_list,
             "DATE_TRUNC": build_timestamp_trunc,
             "DIV": lambda args: exp.cast(
                 binary_from_function(exp.IntDiv)(args), exp.DataType.Type.DECIMAL
@@ -418,6 +424,11 @@ class Postgres(Dialect):
         FUNCTION_PARSERS = {
             **parser.Parser.FUNCTION_PARSERS,
             "DATE_PART": lambda self: self._parse_date_part(),
+            "JSON_AGG": lambda self: self.expression(
+                exp.JSONArrayAgg,
+                this=self._parse_bitwise(),
+                order=self._parse_order(),
+            ),
             "JSONB_EXISTS": lambda self: self._parse_jsonb_exists(),
         }
 
@@ -584,7 +595,10 @@ class Postgres(Dialect):
             exp.AnyValue: _versioned_anyvalue_sql,
             exp.ArrayConcat: lambda self, e: self.arrayconcat_sql(e, name="ARRAY_CAT"),
             exp.ArrayFilter: filter_array_using_unnest,
+            exp.BitwiseAndAgg: rename_func("BIT_AND"),
+            exp.BitwiseOrAgg: rename_func("BIT_OR"),
             exp.BitwiseXor: lambda self, e: self.binary(e, "#"),
+            exp.BitwiseXorAgg: rename_func("BIT_XOR"),
             exp.ColumnDef: transforms.preprocess([_auto_increment_to_serial, _serial_to_generated]),
             exp.CurrentDate: no_paren_current_date_sql,
             exp.CurrentTimestamp: lambda *_: "CURRENT_TIMESTAMP",
@@ -599,6 +613,11 @@ class Postgres(Dialect):
                 self, e, func_name="STRING_AGG", within_group=False
             ),
             exp.IntDiv: rename_func("DIV"),
+            exp.JSONArrayAgg: lambda self, e: self.func(
+                "JSON_AGG",
+                self.sql(e, "this"),
+                suffix=f"{self.sql(e, 'order')})",
+            ),
             exp.JSONExtract: _json_extract_sql("JSON_EXTRACT_PATH", "->"),
             exp.JSONExtractScalar: _json_extract_sql("JSON_EXTRACT_PATH_TEXT", "->>"),
             exp.JSONBExtract: lambda self, e: self.binary(e, "#>"),

sqlglot/dialects/redshift.py

@@ -162,6 +162,7 @@ class Redshift(Postgres):
         ALTER_SET_TYPE = "TYPE"
         SUPPORTS_DECODE_CASE = True
         SUPPORTS_BETWEEN_FLAGS = False
+        LIMIT_FETCH = "LIMIT"
 
         # Redshift doesn't have `WITH` as part of their with_properties so we remove it
         WITH_PROPERTIES_PREFIX = " "

sqlglot/dialects/singlestore.py

@@ -16,7 +16,7 @@ from sqlglot.dialects.dialect import (
     date_add_interval_sql,
     timestampdiff_sql,
 )
-from sqlglot.dialects.mysql import MySQL, _remove_ts_or_ds_to_date, date_add_sql
+from sqlglot.dialects.mysql import MySQL, _remove_ts_or_ds_to_date, date_add_sql, _show_parser
 from sqlglot.expressions import DataType
 from sqlglot.generator import unsupported_args
 from sqlglot.helper import seq_get
@@ -55,6 +55,17 @@ class SingleStore(MySQL):
         "FF6": "%f",  # only 6 digits are supported in python formats
     }
 
+    VECTOR_TYPE_ALIASES = {
+        "I8": "TINYINT",
+        "I16": "SMALLINT",
+        "I32": "INT",
+        "I64": "BIGINT",
+        "F32": "FLOAT",
+        "F64": "DOUBLE",
+    }
+
+    INVERSE_VECTOR_TYPE_ALIASES = {v: k for k, v in VECTOR_TYPE_ALIASES.items()}
+
     class Tokenizer(MySQL.Tokenizer):
         BYTE_STRINGS = [("e'", "'"), ("E'", "'")]
 
@@ -249,6 +260,63 @@ class SingleStore(MySQL):
         COLUMN_OPERATORS.pop(TokenType.DHASH_ARROW)
         COLUMN_OPERATORS.pop(TokenType.PLACEHOLDER)
 
+        SHOW_PARSERS = {
+            **MySQL.Parser.SHOW_PARSERS,
+            "AGGREGATES": _show_parser("AGGREGATES"),
+            "CDC EXTRACTOR POOL": _show_parser("CDC EXTRACTOR POOL"),
+            "CREATE AGGREGATE": _show_parser("CREATE AGGREGATE", target=True),
+            "CREATE PIPELINE": _show_parser("CREATE PIPELINE", target=True),
+            "CREATE PROJECTION": _show_parser("CREATE PROJECTION", target=True),
+            "DATABASE STATUS": _show_parser("DATABASE STATUS"),
+            "DISTRIBUTED_PLANCACHE STATUS": _show_parser("DISTRIBUTED_PLANCACHE STATUS"),
+            "FULLTEXT SERVICE METRICS LOCAL": _show_parser("FULLTEXT SERVICE METRICS LOCAL"),
+            "FULLTEXT SERVICE METRICS FOR NODE": _show_parser(
+                "FULLTEXT SERVICE METRICS FOR NODE", target=True
+            ),
+            "FULLTEXT SERVICE STATUS": _show_parser("FULLTEXT SERVICE STATUS"),
+            "FUNCTIONS": _show_parser("FUNCTIONS"),
+            "GROUPS": _show_parser("GROUPS"),
+            "GROUPS FOR ROLE": _show_parser("GROUPS FOR ROLE", target=True),
+            "GROUPS FOR USER": _show_parser("GROUPS FOR USER", target=True),
+            "INDEXES": _show_parser("INDEX", target="FROM"),
+            "KEYS": _show_parser("INDEX", target="FROM"),
+            "LINKS": _show_parser("LINKS", target="ON"),
+            "LOAD ERRORS": _show_parser("LOAD ERRORS"),
+            "LOAD WARNINGS": _show_parser("LOAD WARNINGS"),
+            "PARTITIONS": _show_parser("PARTITIONS", target="ON"),
+            "PIPELINES": _show_parser("PIPELINES"),
+            "PLAN": _show_parser("PLAN", target=True),
+            "PLANCACHE": _show_parser("PLANCACHE"),
+            "PROCEDURES": _show_parser("PROCEDURES"),
+            "PROJECTIONS": _show_parser("PROJECTIONS", target="ON TABLE"),
+            "REPLICATION STATUS": _show_parser("REPLICATION STATUS"),
+            "REPRODUCTION": _show_parser("REPRODUCTION"),
+            "RESOURCE POOLS": _show_parser("RESOURCE POOLS"),
+            "ROLES": _show_parser("ROLES"),
+            "ROLES FOR USER": _show_parser("ROLES FOR USER", target=True),
+            "ROLES FOR GROUP": _show_parser("ROLES FOR GROUP", target=True),
+            "STATUS EXTENDED": _show_parser("STATUS EXTENDED"),
+            "USERS": _show_parser("USERS"),
+            "USERS FOR ROLE": _show_parser("USERS FOR ROLE", target=True),
+            "USERS FOR GROUP": _show_parser("USERS FOR GROUP", target=True),
+        }
+
+        ALTER_PARSERS = {
+            **MySQL.Parser.ALTER_PARSERS,
+            "CHANGE": lambda self: self.expression(
+                exp.RenameColumn, this=self._parse_column(), to=self._parse_column()
+            ),
+        }
+
+        def _parse_vector_expressions(
+            self, expressions: t.List[exp.Expression]
+        ) -> t.List[exp.Expression]:
+            type_name = expressions[1].name.upper()
+            if type_name in self.dialect.VECTOR_TYPE_ALIASES:
+                type_name = self.dialect.VECTOR_TYPE_ALIASES[type_name]
+
+            return [exp.DataType.build(type_name, dialect=self.dialect), expressions[0]]
+
     class Generator(MySQL.Generator):
         SUPPORTS_UESCAPE = False
         NULL_ORDERING_SUPPORTED = True
@@ -459,6 +527,7 @@ class SingleStore(MySQL):
                 e.expression,
                 self.func("SUBSTRING", e.this, e.args.get("start") + e.args.get("length")),
             ),
+            exp.National: lambda self, e: self.national_sql(e, prefix=""),
             exp.Reduce: unsupported_args("finish")(
                 lambda self, e: self.func(
                     "REDUCE", e.args.get("initial"), e.this, e.args.get("merge")
@@ -467,6 +536,29 @@ class SingleStore(MySQL):
             exp.MatchAgainst: unsupported_args("modifier")(
                 lambda self, e: super().matchagainst_sql(e)
             ),
+            exp.Show: unsupported_args(
+                "history",
+                "terse",
+                "offset",
+                "starts_with",
+                "limit",
+                "from",
+                "scope",
+                "scope_kind",
+                "mutex",
+                "query",
+                "channel",
+                "log",
+                "types",
+                "privileges",
+            )(lambda self, e: super().show_sql(e)),
+            exp.Describe: unsupported_args(
+                "style",
+                "kind",
+                "expressions",
+                "partition",
+                "format",
+            )(lambda self, e: super().describe_sql(e)),
         }
         TRANSFORMS.pop(exp.JSONExtractScalar)
         TRANSFORMS.pop(exp.CurrentDate)
@@ -1685,6 +1777,14 @@ class SingleStore(MySQL):
                     return f"DECIMAL({precision}, {scale[0]})"
                 else:
                     return f"DECIMAL({precision})"
+            if expression.is_type(exp.DataType.Type.VECTOR):
+                expressions = expression.expressions
+                if len(expressions) == 2:
+                    type_name = self.sql(expressions[0])
+                    if type_name in self.dialect.INVERSE_VECTOR_TYPE_ALIASES:
+                        type_name = self.dialect.INVERSE_VECTOR_TYPE_ALIASES[type_name]
+
+                    return f"VECTOR({self.sql(expressions[1])}, {type_name})"
 
             return super().datatype_sql(expression)
 
@@ -1741,3 +1841,31 @@ class SingleStore(MySQL):
 
             self.unsupported("STANDARD_HASH function is not supported in SingleStore")
             return self.func("SHA", expression.this)
+
+        @unsupported_args("is_database", "exists", "cluster", "identity", "option", "partition")
+        def truncatetable_sql(self, expression: exp.TruncateTable) -> str:
+            statements = []
+            for expression in expression.expressions:
+                statements.append(f"TRUNCATE {self.sql(expression)}")
+
+            return "; ".join(statements)
+
+        @unsupported_args("exists")
+        def renamecolumn_sql(self, expression: exp.RenameColumn) -> str:
+            old_column = self.sql(expression, "this")
+            new_column = self.sql(expression, "to")
+            return f"CHANGE {old_column} {new_column}"
+
+        @unsupported_args("drop", "comment", "allow_null", "visible", "using")
+        def altercolumn_sql(self, expression: exp.AlterColumn) -> str:
+            alter = super().altercolumn_sql(expression)
+
+            collate = self.sql(expression, "collate")
+            collate = f" COLLATE {collate}" if collate else ""
+            return f"{alter}{collate}"
+
+        def computedcolumnconstraint_sql(self, expression: exp.ComputedColumnConstraint) -> str:
+            this = self.sql(expression, "this")
+            not_null = " NOT NULL" if expression.args.get("not_null") else ""
+            type = self.sql(expression, "data_type") or "AUTO"
+            return f"AS {this} PERSISTED {type}{not_null}"