sqlglot 27.8.0__py3-none-any.whl → 27.10.0__py3-none-any.whl

sqlglot/dialects/duckdb.py

@@ -386,10 +386,12 @@ class DuckDB(Dialect):
             "JSON_EXTRACT_PATH": parser.build_extract_json_with_path(exp.JSONExtract),
             "JSON_EXTRACT_STRING": parser.build_extract_json_with_path(exp.JSONExtractScalar),
             "LIST_CONTAINS": exp.ArrayContains.from_arg_list,
+            "LIST_FILTER": exp.ArrayFilter.from_arg_list,
             "LIST_HAS": exp.ArrayContains.from_arg_list,
             "LIST_HAS_ANY": exp.ArrayOverlaps.from_arg_list,
             "LIST_REVERSE_SORT": _build_sort_array_desc,
             "LIST_SORT": exp.SortArray.from_arg_list,
+            "LIST_TRANSFORM": exp.Transform.from_arg_list,
             "LIST_VALUE": lambda args: exp.Array(expressions=args),
             "MAKE_TIME": exp.TimeFromParts.from_arg_list,
             "MAKE_TIMESTAMP": _build_make_timestamp,
@@ -643,6 +645,9 @@ class DuckDB(Dialect):
             exp.ArrayRemove: remove_from_array_using_filter,
             exp.ArraySort: _array_sort_sql,
             exp.ArraySum: rename_func("LIST_SUM"),
+            exp.ArrayUniqueAgg: lambda self, e: self.func(
+                "LIST", exp.Distinct(expressions=[e.this])
+            ),
             exp.BitwiseXor: rename_func("XOR"),
             exp.CommentColumnConstraint: no_comment_column_constraint_sql,
             exp.CurrentDate: lambda *_: "CURRENT_DATE",
@@ -1117,15 +1122,20 @@ class DuckDB(Dialect):
             return super().unnest_sql(expression)
 
         def ignorenulls_sql(self, expression: exp.IgnoreNulls) -> str:
-            if isinstance(expression.this, self.IGNORE_RESPECT_NULLS_WINDOW_FUNCTIONS):
+            this = expression.this
+
+            if isinstance(this, self.IGNORE_RESPECT_NULLS_WINDOW_FUNCTIONS):
                 # DuckDB should render IGNORE NULLS only for the general-purpose
                 # window functions that accept it e.g. FIRST_VALUE(... IGNORE NULLS) OVER (...)
                 return super().ignorenulls_sql(expression)
 
-            if not isinstance(expression.this, exp.AnyValue):
+            if isinstance(this, exp.First):
+                this = exp.AnyValue(this=this.this)
+
+            if not isinstance(this, exp.AnyValue):
                 self.unsupported("IGNORE NULLS is not supported for non-window functions.")
 
-            return self.sql(expression, "this")
+            return self.sql(this)
 
         def respectnulls_sql(self, expression: exp.RespectNulls) -> str:
             if isinstance(expression.this, self.IGNORE_RESPECT_NULLS_WINDOW_FUNCTIONS):

sqlglot/dialects/exasol.py

@@ -5,8 +5,10 @@ import typing as t
 from sqlglot import exp, generator, parser, tokens
 from sqlglot.dialects.dialect import (
     Dialect,
+    NormalizationStrategy,
     binary_from_function,
     build_formatted_time,
+    groupconcat_sql,
     rename_func,
     strposition_sql,
     timestrtotime_sql,
@@ -73,6 +75,17 @@ DATE_UNITS = {"DAY", "WEEK", "MONTH", "YEAR", "HOUR", "MINUTE", "SECOND"}
 
 
 class Exasol(Dialect):
+    # https://docs.exasol.com/db/latest/sql_references/basiclanguageelements.htm#SQLidentifier
+    NORMALIZATION_STRATEGY = NormalizationStrategy.UPPERCASE
+    # https://docs.exasol.com/db/latest/sql_references/data_types/datatypesoverview.htm
+    SUPPORTS_USER_DEFINED_TYPES = False
+    # https://docs.exasol.com/db/latest/sql/select.htm
+    SUPPORTS_SEMI_ANTI_JOIN = False
+    SUPPORTS_COLUMN_JOIN_MARKS = True
+    NULL_ORDERING = "nulls_are_last"
+    # https://docs.exasol.com/db/latest/sql_references/literals.htm#StringLiterals
+    CONCAT_COALESCE = True
+
     TIME_MAPPING = {
         "yyyy": "%Y",
         "YYYY": "%Y",
@@ -108,6 +121,7 @@ class Exasol(Dialect):
             # https://docs.exasol.com/db/latest/sql_references/functions/alphabeticallistfunctions/if.htm
             "ENDIF": TokenType.END,
             "LONG VARCHAR": TokenType.TEXT,
+            "SEPARATOR": TokenType.SEPARATOR,
         }
         KEYWORDS.pop("DIV")
 
@@ -176,6 +190,12 @@ class Exasol(Dialect):
                 this=self._match(TokenType.IS) and self._parse_string(),
             ),
         }
+        FUNCTION_PARSERS = {
+            **parser.Parser.FUNCTION_PARSERS,
+            # https://docs.exasol.com/db/latest/sql_references/functions/alphabeticallistfunctions/listagg.htm
+            # https://docs.exasol.com/db/latest/sql_references/functions/alphabeticallistfunctions/group_concat.htm
+            **dict.fromkeys(("GROUP_CONCAT", "LISTAGG"), lambda self: self._parse_group_concat()),
+        }
 
     class Generator(generator.Generator):
         # https://docs.exasol.com/db/latest/sql_references/data_types/datatypedetails.htm#StringDataType
@@ -235,6 +255,9 @@ class Exasol(Dialect):
             exp.TsOrDsDiff: _date_diff_sql,
             exp.DateTrunc: lambda self, e: self.func("TRUNC", e.this, unit_to_str(e)),
             exp.DatetimeTrunc: timestamptrunc_sql(),
+            exp.GroupConcat: lambda self, e: groupconcat_sql(
+                self, e, func_name="LISTAGG", within_group=True
+            ),
             # https://docs.exasol.com/db/latest/sql_references/functions/alphabeticallistfunctions/edit_distance.htm#EDIT_DISTANCE
             exp.Levenshtein: unsupported_args("ins_cost", "del_cost", "sub_cost", "max_dist")(
                 rename_func("EDIT_DISTANCE")

sqlglot/dialects/mysql.py

@@ -676,39 +676,6 @@ class MySQL(Dialect):
                 parse_interval=parse_interval, fallback_to_identifier=fallback_to_identifier
             )
 
-        def _parse_group_concat(self) -> t.Optional[exp.Expression]:
-            def concat_exprs(
-                node: t.Optional[exp.Expression], exprs: t.List[exp.Expression]
-            ) -> exp.Expression:
-                if isinstance(node, exp.Distinct) and len(node.expressions) > 1:
-                    concat_exprs = [
-                        self.expression(exp.Concat, expressions=node.expressions, safe=True)
-                    ]
-                    node.set("expressions", concat_exprs)
-                    return node
-                if len(exprs) == 1:
-                    return exprs[0]
-                return self.expression(exp.Concat, expressions=args, safe=True)
-
-            args = self._parse_csv(self._parse_lambda)
-
-            if args:
-                order = args[-1] if isinstance(args[-1], exp.Order) else None
-
-                if order:
-                    # Order By is the last (or only) expression in the list and has consumed the 'expr' before it,
-                    # remove 'expr' from exp.Order and add it back to args
-                    args[-1] = order.this
-                    order.set("this", concat_exprs(order.this, args))
-
-                this = order or concat_exprs(args[0], args)
-            else:
-                this = None
-
-            separator = self._parse_field() if self._match(TokenType.SEPARATOR) else None
-
-            return self.expression(exp.GroupConcat, this=this, separator=separator)
-
         def _parse_alter_table_alter_index(self) -> exp.AlterIndex:
             index = self._parse_field(any_token=True)
 

sqlglot/dialects/postgres.py

@@ -345,7 +345,6 @@ class Postgres(Dialect):
             "REFRESH": TokenType.COMMAND,
             "REINDEX": TokenType.COMMAND,
             "RESET": TokenType.COMMAND,
-            "REVOKE": TokenType.COMMAND,
             "SERIAL": TokenType.SERIAL,
             "SMALLSERIAL": TokenType.SMALLSERIAL,
             "TEMP": TokenType.TEMPORARY,

sqlglot/dialects/redshift.py

@@ -192,6 +192,7 @@ class Redshift(Postgres):
             exp.DistKeyProperty: lambda self, e: self.func("DISTKEY", e.this),
             exp.DistStyleProperty: lambda self, e: self.naked_property(e),
             exp.Explode: lambda self, e: self.explode_sql(e),
+            exp.FarmFingerprint: rename_func("FARMFINGERPRINT64"),
             exp.FromBase: rename_func("STRTOL"),
             exp.GeneratedAsIdentityColumnConstraint: generatedasidentitycolumnconstraint_sql,
             exp.JSONExtract: json_extract_segments("JSON_EXTRACT_PATH_TEXT"),

sqlglot/dialects/singlestore.py

@@ -8,12 +8,25 @@ from sqlglot.dialects.dialect import (
     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
 
@@ -56,22 +69,55 @@ 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"),
+            "TIME_BUCKET": lambda args: exp.DateBin(
+                this=seq_get(args, 0),
+                expression=seq_get(args, 1),
+                origin=seq_get(args, 2),
+            ),
             "BSON_EXTRACT_BSON": build_json_extract_path(exp.JSONBExtract),
             "BSON_EXTRACT_STRING": build_json_extract_path(
                 exp.JSONBExtractScalar, json_type="STRING"
@@ -92,7 +138,52 @@ class SingleStore(MySQL):
             "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",
+            ),
+            "JSON_PRETTY": exp.JSONFormat.from_arg_list,
             "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),
+            ),
+            "REDUCE": lambda args: exp.Reduce(
+                initial=seq_get(args, 0),
+                this=seq_get(args, 1),
+                merge=seq_get(args, 2),
+            ),
         }
 
         CAST_COLUMN_OPERATORS = {TokenType.COLON_GT, TokenType.NCOLON_GT}
@@ -128,7 +219,9 @@ class SingleStore(MySQL):
 
         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(
@@ -181,6 +274,9 @@ class SingleStore(MySQL):
                 ),
             ),
             exp.UnixToTimeStr: lambda self, e: f"FROM_UNIXTIME({self.sql(e, 'this')}) :> TEXT",
+            exp.DateBin: unsupported_args("unit", "zone")(
+                lambda self, e: self.func("TIME_BUCKET", e.this, e.expression, e.args.get("origin"))
+            ),
             exp.JSONExtract: unsupported_args(
                 "only_json_types",
                 "expressions",
@@ -195,15 +291,67 @@ class SingleStore(MySQL):
             exp.JSONPathKey: json_path_key_only_name,
             exp.JSONPathSubscript: lambda self, e: self.json_path_part(e.this),
             exp.JSONPathRoot: lambda *_: "",
+            exp.JSONFormat: unsupported_args("options", "is_json")(rename_func("JSON_PRETTY")),
+            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)
+            ),
+            exp.Reduce: unsupported_args("finish")(
+                lambda self, e: self.func(
+                    "REDUCE", e.args.get("initial"), e.this, e.args.get("merge")
+                )
+            ),
         }
         TRANSFORMS.pop(exp.JSONExtractScalar)
-        TRANSFORMS.pop(exp.JSONPathFilter)
-        TRANSFORMS.pop(exp.JSONPathRecursive)
-        TRANSFORMS.pop(exp.JSONPathScript)
-        TRANSFORMS.pop(exp.JSONPathSelector)
-        TRANSFORMS.pop(exp.JSONPathSlice)
-        TRANSFORMS.pop(exp.JSONPathUnion)
-        TRANSFORMS.pop(exp.JSONPathWildcard)
 
         # https://docs.singlestore.com/cloud/reference/sql-reference/restricted-keywords/list-of-restricted-keywords/
         RESERVED_KEYWORDS = {
@@ -1286,3 +1434,21 @@ class SingleStore(MySQL):
                 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/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)