sqlglot 27.7.0__py3-none-any.whl → 27.9.0__py3-none-any.whl

sqlglot/dialects/singlestore.py

@@ -2,12 +2,31 @@ from sqlglot import TokenType
 import typing as t
 
 from sqlglot import exp
-from sqlglot.dialects.dialect import build_formatted_time, rename_func
+from sqlglot.dialects.dialect import (
+    build_formatted_time,
+    build_json_extract_path,
+    json_extract_segments,
+    json_path_key_only_name,
+    rename_func,
+    bool_xor_sql,
+    count_if_to_sum,
+)
 from sqlglot.dialects.mysql import MySQL
+from sqlglot.expressions import DataType
 from sqlglot.generator import unsupported_args
 from sqlglot.helper import seq_get
 
 
+def cast_to_time6(expression: t.Optional[exp.Expression]) -> exp.Cast:
+    return exp.Cast(
+        this=expression,
+        to=exp.DataType.build(
+            exp.DataType.Type.TIME,
+            expressions=[exp.DataTypeParam(this=exp.Literal.number(6))],
+        ),
+    )
+
+
 class SingleStore(MySQL):
     SUPPORTS_ORDER_BY_ALL = True
 
@@ -50,22 +69,110 @@ class SingleStore(MySQL):
             "TO_CHAR": build_formatted_time(exp.ToChar, "singlestore"),
             "STR_TO_DATE": build_formatted_time(exp.StrToDate, "mysql"),
             "DATE_FORMAT": build_formatted_time(exp.TimeToStr, "mysql"),
+            # The first argument of following functions is converted to TIME(6)
+            # This is needed because exp.TimeToStr is converted to DATE_FORMAT
+            # which interprets the first argument as DATETIME and fails to parse
+            # string literals like '12:05:47' without a date part.
             "TIME_FORMAT": lambda args: exp.TimeToStr(
-                # The first argument is converted to TIME(6)
-                # This is needed because exp.TimeToStr is converted to DATE_FORMAT
-                # which interprets the first argument as DATETIME and fails to parse
-                # string literals like '12:05:47' without a date part.
-                this=exp.Cast(
-                    this=seq_get(args, 0),
-                    to=exp.DataType.build(
-                        exp.DataType.Type.TIME,
-                        expressions=[exp.DataTypeParam(this=exp.Literal.number(6))],
-                    ),
-                ),
+                this=cast_to_time6(seq_get(args, 0)),
                 format=MySQL.format_time(seq_get(args, 1)),
             ),
+            "HOUR": lambda args: exp.cast(
+                exp.TimeToStr(
+                    this=cast_to_time6(seq_get(args, 0)),
+                    format=MySQL.format_time(exp.Literal.string("%k")),
+                ),
+                DataType.Type.INT,
+            ),
+            "MICROSECOND": lambda args: exp.cast(
+                exp.TimeToStr(
+                    this=cast_to_time6(seq_get(args, 0)),
+                    format=MySQL.format_time(exp.Literal.string("%f")),
+                ),
+                DataType.Type.INT,
+            ),
+            "SECOND": lambda args: exp.cast(
+                exp.TimeToStr(
+                    this=cast_to_time6(seq_get(args, 0)),
+                    format=MySQL.format_time(exp.Literal.string("%s")),
+                ),
+                DataType.Type.INT,
+            ),
+            "MINUTE": lambda args: exp.cast(
+                exp.TimeToStr(
+                    this=cast_to_time6(seq_get(args, 0)),
+                    format=MySQL.format_time(exp.Literal.string("%i")),
+                ),
+                DataType.Type.INT,
+            ),
+            "MONTHNAME": lambda args: exp.TimeToStr(
+                this=seq_get(args, 0),
+                format=MySQL.format_time(exp.Literal.string("%M")),
+            ),
+            "WEEKDAY": lambda args: exp.paren(exp.DayOfWeek(this=seq_get(args, 0)) + 5, copy=False)
+            % 7,
             "UNIX_TIMESTAMP": exp.StrToUnix.from_arg_list,
             "FROM_UNIXTIME": build_formatted_time(exp.UnixToTime, "mysql"),
+            "BSON_EXTRACT_BSON": build_json_extract_path(exp.JSONBExtract),
+            "BSON_EXTRACT_STRING": build_json_extract_path(
+                exp.JSONBExtractScalar, json_type="STRING"
+            ),
+            "BSON_EXTRACT_DOUBLE": build_json_extract_path(
+                exp.JSONBExtractScalar, json_type="DOUBLE"
+            ),
+            "BSON_EXTRACT_BIGINT": build_json_extract_path(
+                exp.JSONBExtractScalar, json_type="BIGINT"
+            ),
+            "JSON_EXTRACT_JSON": build_json_extract_path(exp.JSONExtract),
+            "JSON_EXTRACT_STRING": build_json_extract_path(
+                exp.JSONExtractScalar, json_type="STRING"
+            ),
+            "JSON_EXTRACT_DOUBLE": build_json_extract_path(
+                exp.JSONExtractScalar, json_type="DOUBLE"
+            ),
+            "JSON_EXTRACT_BIGINT": build_json_extract_path(
+                exp.JSONExtractScalar, json_type="BIGINT"
+            ),
+            "JSON_ARRAY_CONTAINS_STRING": lambda args: exp.JSONArrayContains(
+                this=seq_get(args, 1),
+                expression=seq_get(args, 0),
+                json_type="STRING",
+            ),
+            "JSON_ARRAY_CONTAINS_DOUBLE": lambda args: exp.JSONArrayContains(
+                this=seq_get(args, 1),
+                expression=seq_get(args, 0),
+                json_type="DOUBLE",
+            ),
+            "JSON_ARRAY_CONTAINS_JSON": lambda args: exp.JSONArrayContains(
+                this=seq_get(args, 1),
+                expression=seq_get(args, 0),
+                json_type="JSON",
+            ),
+            "DATE": exp.Date.from_arg_list,
+            "DAYNAME": lambda args: exp.TimeToStr(
+                this=seq_get(args, 0),
+                format=MySQL.format_time(exp.Literal.string("%W")),
+            ),
+            "APPROX_COUNT_DISTINCT": exp.Hll.from_arg_list,
+            "APPROX_PERCENTILE": lambda args, dialect: exp.ApproxQuantile(
+                this=seq_get(args, 0),
+                quantile=seq_get(args, 1),
+                error_tolerance=seq_get(args, 2),
+            ),
+            "VARIANCE": exp.VariancePop.from_arg_list,
+            "INSTR": exp.Contains.from_arg_list,
+            "REGEXP_MATCH": lambda args: exp.RegexpExtractAll(
+                this=seq_get(args, 0),
+                expression=seq_get(args, 1),
+                parameters=seq_get(args, 2),
+            ),
+            "REGEXP_SUBSTR": lambda args: exp.RegexpExtract(
+                this=seq_get(args, 0),
+                expression=seq_get(args, 1),
+                position=seq_get(args, 2),
+                occurrence=seq_get(args, 3),
+                parameters=seq_get(args, 4),
+            ),
         }
 
         CAST_COLUMN_OPERATORS = {TokenType.COLON_GT, TokenType.NCOLON_GT}
@@ -81,12 +188,29 @@ class SingleStore(MySQL):
                 this=this,
                 to=to,
             ),
+            TokenType.DCOLON: lambda self, this, path: build_json_extract_path(exp.JSONExtract)(
+                [this, exp.Literal.string(path.name)]
+            ),
+            TokenType.DCOLONDOLLAR: lambda self, this, path: build_json_extract_path(
+                exp.JSONExtractScalar, json_type="STRING"
+            )([this, exp.Literal.string(path.name)]),
+            TokenType.DCOLONPERCENT: lambda self, this, path: build_json_extract_path(
+                exp.JSONExtractScalar, json_type="DOUBLE"
+            )([this, exp.Literal.string(path.name)]),
         }
 
     class Generator(MySQL.Generator):
+        SUPPORTED_JSON_PATH_PARTS = {
+            exp.JSONPathKey,
+            exp.JSONPathRoot,
+            exp.JSONPathSubscript,
+        }
+
         TRANSFORMS = {
             **MySQL.Generator.TRANSFORMS,
-            exp.TsOrDsToDate: lambda self, e: self.func("TO_DATE", e.this, self.format_time(e)),
+            exp.TsOrDsToDate: lambda self, e: self.func("TO_DATE", e.this, self.format_time(e))
+            if e.args.get("format")
+            else self.func("DATE", e.this),
             exp.StrToTime: lambda self, e: self.func("TO_TIMESTAMP", e.this, self.format_time(e)),
             exp.ToChar: lambda self, e: self.func("TO_CHAR", e.this, self.format_time(e)),
             exp.StrToDate: lambda self, e: self.func(
@@ -107,6 +231,7 @@ class SingleStore(MySQL):
                     inverse_time_trie=MySQL.INVERSE_TIME_TRIE,
                 ),
             ),
+            exp.Date: unsupported_args("zone", "expressions")(rename_func("DATE")),
             exp.Cast: unsupported_args("format", "action", "default")(
                 lambda self, e: f"{self.sql(e, 'this')} :> {self.sql(e, 'to')}"
             ),
@@ -138,7 +263,75 @@ class SingleStore(MySQL):
                 ),
             ),
             exp.UnixToTimeStr: lambda self, e: f"FROM_UNIXTIME({self.sql(e, 'this')}) :> TEXT",
+            exp.JSONExtract: unsupported_args(
+                "only_json_types",
+                "expressions",
+                "variant_extract",
+                "json_query",
+                "option",
+                "quote",
+                "on_condition",
+                "requires_json",
+            )(json_extract_segments("JSON_EXTRACT_JSON")),
+            exp.JSONBExtract: json_extract_segments("BSON_EXTRACT_BSON"),
+            exp.JSONPathKey: json_path_key_only_name,
+            exp.JSONPathSubscript: lambda self, e: self.json_path_part(e.this),
+            exp.JSONPathRoot: lambda *_: "",
+            exp.DayOfWeekIso: lambda self, e: f"(({self.func('DAYOFWEEK', e.this)} % 7) + 1)",
+            exp.DayOfMonth: rename_func("DAY"),
+            exp.Hll: rename_func("APPROX_COUNT_DISTINCT"),
+            exp.ApproxDistinct: rename_func("APPROX_COUNT_DISTINCT"),
+            exp.CountIf: count_if_to_sum,
+            exp.LogicalOr: lambda self, e: f"MAX(ABS({self.sql(e, 'this')}))",
+            exp.LogicalAnd: lambda self, e: f"MIN(ABS({self.sql(e, 'this')}))",
+            exp.ApproxQuantile: unsupported_args("accuracy", "weight")(
+                lambda self, e: self.func(
+                    "APPROX_PERCENTILE",
+                    e.this,
+                    e.args.get("quantile"),
+                    e.args.get("error_tolerance"),
+                )
+            ),
+            exp.Variance: rename_func("VAR_SAMP"),
+            exp.VariancePop: rename_func("VAR_POP"),
+            exp.Xor: bool_xor_sql,
+            exp.RegexpLike: lambda self, e: self.binary(e, "RLIKE"),
+            exp.Repeat: lambda self, e: self.func(
+                "LPAD",
+                exp.Literal.string(""),
+                exp.Mul(this=self.func("LENGTH", e.this), expression=e.args.get("times")),
+                e.this,
+            ),
+            exp.IsAscii: lambda self, e: f"({self.sql(e, 'this')} RLIKE '^[\x00-\x7f]*$')",
+            exp.MD5Digest: lambda self, e: self.func("UNHEX", self.func("MD5", e.this)),
+            exp.Chr: rename_func("CHAR"),
+            exp.Contains: rename_func("INSTR"),
+            exp.RegexpExtractAll: unsupported_args("position", "occurrence", "group")(
+                lambda self, e: self.func(
+                    "REGEXP_MATCH",
+                    e.this,
+                    e.expression,
+                    e.args.get("parameters"),
+                )
+            ),
+            exp.RegexpExtract: unsupported_args("group")(
+                lambda self, e: self.func(
+                    "REGEXP_SUBSTR",
+                    e.this,
+                    e.expression,
+                    e.args.get("position"),
+                    e.args.get("occurrence"),
+                    e.args.get("parameters"),
+                )
+            ),
+            exp.StartsWith: lambda self, e: self.func(
+                "REGEXP_INSTR", e.this, self.func("CONCAT", exp.Literal.string("^"), e.expression)
+            ),
+            exp.FromBase: lambda self, e: self.func(
+                "CONV", e.this, e.expression, exp.Literal.number(10)
+            ),
         }
+        TRANSFORMS.pop(exp.JSONExtractScalar)
 
         # https://docs.singlestore.com/cloud/reference/sql-reference/restricted-keywords/list-of-restricted-keywords/
         RESERVED_KEYWORDS = {
@@ -1193,3 +1386,49 @@ class SingleStore(MySQL):
             "zerofill",
             "zone",
         }
+
+        def jsonextractscalar_sql(self, expression: exp.JSONExtractScalar) -> str:
+            json_type = expression.args.get("json_type")
+            func_name = "JSON_EXTRACT_JSON" if json_type is None else f"JSON_EXTRACT_{json_type}"
+            return json_extract_segments(func_name)(self, expression)
+
+        def jsonbextractscalar_sql(self, expression: exp.JSONBExtractScalar) -> str:
+            json_type = expression.args.get("json_type")
+            func_name = "BSON_EXTRACT_BSON" if json_type is None else f"BSON_EXTRACT_{json_type}"
+            return json_extract_segments(func_name)(self, expression)
+
+        def jsonextractarray_sql(self, expression: exp.JSONExtractArray) -> str:
+            self.unsupported("Arrays are not supported in SingleStore")
+            return self.function_fallback_sql(expression)
+
+        @unsupported_args("on_condition")
+        def jsonvalue_sql(self, expression: exp.JSONValue) -> str:
+            res: exp.Expression = exp.JSONExtractScalar(
+                this=expression.this,
+                expression=expression.args.get("path"),
+                json_type="STRING",
+            )
+
+            returning = expression.args.get("returning")
+            if returning is not None:
+                res = exp.Cast(this=res, to=returning)
+
+            return self.sql(res)
+
+        def all_sql(self, expression: exp.All) -> str:
+            self.unsupported("ALL subquery predicate is not supported in SingleStore")
+            return super().all_sql(expression)
+
+        def jsonarraycontains_sql(self, expression: exp.JSONArrayContains) -> str:
+            json_type = expression.text("json_type").upper()
+
+            if json_type:
+                return self.func(
+                    f"JSON_ARRAY_CONTAINS_{json_type}", expression.expression, expression.this
+                )
+
+            return self.func(
+                "JSON_ARRAY_CONTAINS_JSON",
+                expression.expression,
+                self.func("TO_JSON", expression.this),
+            )

sqlglot/dialects/spark.py

@@ -9,6 +9,7 @@ from sqlglot.dialects.dialect import (
     unit_to_var,
     timestampdiff_sql,
     build_date_delta,
+    date_delta_to_binary_interval_op,
     groupconcat_sql,
 )
 from sqlglot.dialects.hive import _build_with_ignore_nulls
@@ -195,13 +196,18 @@ class Spark(Spark2):
                 ]
             ),
             exp.DateFromUnixDate: rename_func("DATE_FROM_UNIX_DATE"),
+            exp.DatetimeAdd: date_delta_to_binary_interval_op(cast=False),
+            exp.DatetimeSub: date_delta_to_binary_interval_op(cast=False),
             exp.GroupConcat: _groupconcat_sql,
             exp.EndsWith: rename_func("ENDSWITH"),
             exp.PartitionedByProperty: lambda self,
             e: f"PARTITIONED BY {self.wrap(self.expressions(sqls=[_normalize_partition(e) for e in e.this.expressions], skip_first=True))}",
             exp.StartsWith: rename_func("STARTSWITH"),
+            exp.TimeAdd: date_delta_to_binary_interval_op(cast=False),
+            exp.TimeSub: date_delta_to_binary_interval_op(cast=False),
             exp.TsOrDsAdd: _dateadd_sql,
             exp.TimestampAdd: _dateadd_sql,
+            exp.TimestampSub: date_delta_to_binary_interval_op(cast=False),
             exp.DatetimeDiff: timestampdiff_sql,
             exp.TimestampDiff: timestampdiff_sql,
             exp.TryCast: lambda self, e: (

sqlglot/dialects/trino.py

@@ -21,6 +21,7 @@ class Trino(Presto):
             **Presto.Parser.FUNCTION_PARSERS,
             "TRIM": lambda self: self._parse_trim(),
             "JSON_QUERY": lambda self: self._parse_json_query(),
+            "JSON_VALUE": lambda self: self._parse_json_value(),
             "LISTAGG": lambda self: self._parse_string_agg(),
         }
 

sqlglot/dialects/tsql.py

@@ -658,6 +658,8 @@ class TSQL(Dialect):
             else self.expression(exp.ScopeResolution, this=this, expression=to),
         }
 
+        SET_OP_MODIFIERS = {"offset"}
+
         def _parse_alter_table_set(self) -> exp.AlterSet:
             return self._parse_wrapped(super()._parse_alter_table_set)
 

sqlglot/expressions.py

@@ -2790,6 +2790,11 @@ class BackupProperty(Property):
     arg_types = {"this": True}
 
 
+# https://doris.apache.org/docs/sql-manual/sql-statements/table-and-view/async-materialized-view/CREATE-ASYNC-MATERIALIZED-VIEW/
+class BuildProperty(Property):
+    arg_types = {"this": True}
+
+
 class BlockCompressionProperty(Property):
     arg_types = {
         "autotemp": False,
@@ -3031,6 +3036,27 @@ class PartitionByRangePropertyDynamic(Expression):
     arg_types = {"this": False, "start": True, "end": True, "every": True}
 
 
+# https://doris.apache.org/docs/table-design/data-partitioning/manual-partitioning
+class PartitionByListProperty(Property):
+    arg_types = {"partition_expressions": True, "create_expressions": True}
+
+
+# https://doris.apache.org/docs/table-design/data-partitioning/manual-partitioning
+class PartitionList(Expression):
+    arg_types = {"this": True, "expressions": True}
+
+
+# https://doris.apache.org/docs/sql-manual/sql-statements/table-and-view/async-materialized-view/CREATE-ASYNC-MATERIALIZED-VIEW
+class RefreshTriggerProperty(Property):
+    arg_types = {
+        "method": True,
+        "kind": False,
+        "every": False,
+        "unit": False,
+        "starts": False,
+    }
+
+
 # https://docs.starrocks.io/docs/sql-reference/sql-statements/table_bucket_part_index/CREATE_TABLE/
 class UniqueKeyProperty(Property):
     arg_types = {"expressions": True}
@@ -4304,7 +4330,14 @@ class Select(Query):
 
     @property
     def named_selects(self) -> t.List[str]:
-        return [e.output_name for e in self.expressions if e.alias_or_name]
+        selects = []
+
+        for e in self.expressions:
+            if e.alias_or_name:
+                selects.append(e.output_name)
+            elif isinstance(e, Aliases):
+                selects.extend([a.name for a in e.aliases])
+        return selects
 
     @property
     def is_star(self) -> bool:
@@ -4876,6 +4909,7 @@ class Alter(Expression):
         "options": False,
         "cluster": False,
         "not_valid": False,
+        "check": False,
     }
 
     @property
@@ -5301,7 +5335,7 @@ class TimeUnit(Expression):
 
     def __init__(self, **args):
         unit = args.get("unit")
-        if isinstance(unit, self.VAR_LIKE):
+        if type(unit) in self.VAR_LIKE:
             args["unit"] = Var(
                 this=(self.UNABBREVIATED_UNIT_NAME.get(unit.name) or unit.name).upper()
             )
@@ -5429,6 +5463,11 @@ class ByteLength(Func):
     pass
 
 
+# https://cloud.google.com/bigquery/docs/reference/standard-sql/json_functions#bool_for_json
+class JSONBool(Func):
+    pass
+
+
 class ArrayRemove(Func):
     arg_types = {"this": True, "expression": True}
 
@@ -5455,15 +5494,42 @@ class ApproxTopK(AggFunc):
     arg_types = {"this": True, "expression": False, "counters": False}
 
 
+class ApproxTopSum(AggFunc):
+    arg_types = {"this": True, "expression": True, "count": True}
+
+
+class ApproxQuantiles(AggFunc):
+    arg_types = {"this": True, "expression": False}
+
+
+class FarmFingerprint(Func):
+    arg_types = {"expressions": True}
+    is_var_len_args = True
+    _sql_names = ["FARM_FINGERPRINT", "FARMFINGERPRINT64"]
+
+
 class Flatten(Func):
     pass
 
 
+class Float64(Func):
+    arg_types = {"this": True, "expression": False}
+
+
 # https://spark.apache.org/docs/latest/api/sql/index.html#transform
 class Transform(Func):
     arg_types = {"this": True, "expression": True}
 
 
+class Translate(Func):
+    arg_types = {"this": True, "from": True, "to": True}
+
+
+class Grouping(AggFunc):
+    arg_types = {"expressions": True}
+    is_var_len_args = True
+
+
 class Anonymous(Func):
     arg_types = {"this": True, "expressions": False}
     is_var_len_args = True
@@ -5531,7 +5597,16 @@ class Pad(Func):
 # https://docs.snowflake.com/en/sql-reference/functions/to_char
 # https://docs.oracle.com/en/database/oracle/oracle-database/23/sqlrf/TO_CHAR-number.html
 class ToChar(Func):
-    arg_types = {"this": True, "format": False, "nlsparam": False}
+    arg_types = {
+        "this": True,
+        "format": False,
+        "nlsparam": False,
+        "is_numeric": False,
+    }
+
+
+class ToCodePoints(Func):
+    pass
 
 
 # https://docs.snowflake.com/en/sql-reference/functions/to_decimal
@@ -5554,6 +5629,10 @@ class ToDouble(Func):
     }
 
 
+class CodePointsToBytes(Func):
+    pass
+
+
 class Columns(Func):
     arg_types = {"this": True, "unpack": False}
 
@@ -6179,12 +6258,16 @@ class Floor(Func):
     arg_types = {"this": True, "decimals": False, "to": False}
 
 
+class FromBase32(Func):
+    pass
+
+
 class FromBase64(Func):
     pass
 
 
-class FeaturesAtTime(Func):
-    arg_types = {"this": True, "time": False, "num_rows": False, "ignore_feature_nulls": False}
+class ToBase32(Func):
+    pass
 
 
 class ToBase64(Func):
@@ -6508,7 +6591,13 @@ class JSONExtractArray(Func):
 
 
 class JSONExtractScalar(Binary, Func):
-    arg_types = {"this": True, "expression": True, "only_json_types": False, "expressions": False}
+    arg_types = {
+        "this": True,
+        "expression": True,
+        "only_json_types": False,
+        "expressions": False,
+        "json_type": False,
+    }
     _sql_names = ["JSON_EXTRACT_SCALAR"]
     is_var_len_args = True
 
@@ -6522,6 +6611,7 @@ class JSONBExtract(Binary, Func):
 
 
 class JSONBExtractScalar(Binary, Func):
+    arg_types = {"this": True, "expression": True, "json_type": False}
     _sql_names = ["JSONB_EXTRACT_SCALAR"]
 
 
@@ -6532,9 +6622,18 @@ class JSONFormat(Func):
 
 # https://dev.mysql.com/doc/refman/8.0/en/json-search-functions.html#operator_member-of
 class JSONArrayContains(Binary, Predicate, Func):
+    arg_types = {"this": True, "expression": True, "json_type": False}
     _sql_names = ["JSON_ARRAY_CONTAINS"]
 
 
+class ParseBignumeric(Func):
+    pass
+
+
+class ParseNumeric(Func):
+    pass
+
+
 class ParseJSON(Func):
     # BigQuery, Snowflake have PARSE_JSON, Presto has JSON_PARSE
     # Snowflake also has TRY_PARSE_JSON, which is represented using `safe`
@@ -6705,6 +6804,29 @@ class Predict(Func):
     arg_types = {"this": True, "expression": True, "params_struct": False}
 
 
+# https://cloud.google.com/bigquery/docs/reference/standard-sql/bigqueryml-syntax-feature-time
+class FeaturesAtTime(Func):
+    arg_types = {"this": True, "time": False, "num_rows": False, "ignore_feature_nulls": False}
+
+
+# https://cloud.google.com/bigquery/docs/reference/standard-sql/bigqueryml-syntax-generate-embedding
+class GenerateEmbedding(Func):
+    arg_types = {"this": True, "expression": True, "params_struct": False}
+
+
+# https://cloud.google.com/bigquery/docs/reference/standard-sql/search_functions#vector_search
+class VectorSearch(Func):
+    arg_types = {
+        "this": True,
+        "column_to_search": True,
+        "query_table": True,
+        "query_column_to_search": False,
+        "top_k": False,
+        "distance_type": False,
+        "options": False,
+    }
+
+
 class Pow(Binary, Func):
     _sql_names = ["POWER", "POW"]
 
@@ -6722,7 +6844,13 @@ class Quantile(AggFunc):
 
 
 class ApproxQuantile(Quantile):
-    arg_types = {"this": True, "quantile": True, "accuracy": False, "weight": False}
+    arg_types = {
+        "this": True,
+        "quantile": True,
+        "accuracy": False,
+        "weight": False,
+        "error_tolerance": False,
+    }
 
 
 class Quarter(Func):
@@ -6824,6 +6952,10 @@ class SafeDivide(Func):
     arg_types = {"this": True, "expression": True}
 
 
+class SafeConvertBytesToString(Func):
+    pass
+
+
 class SHA(Func):
     _sql_names = ["SHA", "SHA1"]
 
@@ -6841,6 +6973,10 @@ class SortArray(Func):
     arg_types = {"this": True, "asc": False}
 
 
+class Soundex(Func):
+    pass
+
+
 class Split(Func):
     arg_types = {"this": True, "expression": True, "limit": False}