sqlglot 27.29.0__py3-none-any.whl → 28.4.0__py3-none-any.whl

sqlglot/dialects/presto.py

@@ -31,6 +31,7 @@ from sqlglot.dialects.dialect import (
     sequence_sql,
     build_regexp_extract,
     explode_to_unnest_sql,
+    sha2_digest_sql,
 )
 from sqlglot.dialects.hive import Hive
 from sqlglot.dialects.mysql import MySQL
@@ -39,11 +40,18 @@ from sqlglot.optimizer.scope import find_all_in_scope
 from sqlglot.tokens import TokenType
 from sqlglot.transforms import unqualify_columns
 from sqlglot.generator import unsupported_args
+from sqlglot.typing.presto import EXPRESSION_METADATA
 
 DATE_ADD_OR_SUB = t.Union[exp.DateAdd, exp.TimestampAdd, exp.DateSub]
 
 
 def _initcap_sql(self: Presto.Generator, expression: exp.Initcap) -> str:
+    delimiters = expression.expression
+    if delimiters and not (
+        delimiters.is_string and delimiters.this == self.dialect.INITCAP_DEFAULT_DELIMITER_CHARS
+    ):
+        self.unsupported("INITCAP does not support custom delimiters")
+
     regex = r"(\w)(\w*)"
     return f"REGEXP_REPLACE({self.sql(expression, 'this')}, '{regex}', x -> UPPER(x[1]) || LOWER(x[2]))"
 
@@ -267,20 +275,7 @@ class Presto(Dialect):
     # https://github.com/prestodb/presto/issues/2863
     NORMALIZATION_STRATEGY = NormalizationStrategy.CASE_INSENSITIVE
 
-    # The result of certain math functions in Presto/Trino is of type
-    # equal to the input type e.g: FLOOR(5.5/2) -> DECIMAL, FLOOR(5/2) -> BIGINT
-    ANNOTATORS = {
-        **Dialect.ANNOTATORS,
-        exp.Floor: lambda self, e: self._annotate_by_args(e, "this"),
-        exp.Ceil: lambda self, e: self._annotate_by_args(e, "this"),
-        exp.Mod: lambda self, e: self._annotate_by_args(e, "this", "expression"),
-        exp.Round: lambda self, e: self._annotate_by_args(e, "this"),
-        exp.Sign: lambda self, e: self._annotate_by_args(e, "this"),
-        exp.Abs: lambda self, e: self._annotate_by_args(e, "this"),
-        exp.Rand: lambda self, e: self._annotate_by_args(e, "this")
-        if e.this
-        else self._set_type(e, exp.DataType.Type.DOUBLE),
-    }
+    EXPRESSION_METADATA = EXPRESSION_METADATA.copy()
 
     SUPPORTED_SETTINGS = {
         *Dialect.SUPPORTED_SETTINGS,
@@ -429,10 +424,19 @@ class Presto(Dialect):
         TRANSFORMS = {
             **generator.Generator.TRANSFORMS,
             exp.AnyValue: rename_func("ARBITRARY"),
-            exp.ApproxQuantile: rename_func("APPROX_PERCENTILE"),
+            exp.ApproxQuantile: lambda self, e: self.func(
+                "APPROX_PERCENTILE",
+                e.this,
+                e.args.get("weight"),
+                e.args.get("quantile"),
+                e.args.get("accuracy"),
+            ),
             exp.ArgMax: rename_func("MAX_BY"),
             exp.ArgMin: rename_func("MIN_BY"),
-            exp.Array: lambda self, e: f"ARRAY[{self.expressions(e, flat=True)}]",
+            exp.Array: transforms.preprocess(
+                [transforms.inherit_struct_field_names],
+                generator=lambda self, e: f"ARRAY[{self.expressions(e, flat=True)}]",
+            ),
             exp.ArrayAny: rename_func("ANY_MATCH"),
             exp.ArrayConcat: rename_func("CONCAT"),
             exp.ArrayContains: rename_func("CONTAINS"),
@@ -542,7 +546,9 @@ class Presto(Dialect):
             exp.Xor: bool_xor_sql,
             exp.MD5Digest: rename_func("MD5"),
             exp.SHA: rename_func("SHA1"),
+            exp.SHA1Digest: rename_func("SHA1"),
             exp.SHA2: sha256_sql,
+            exp.SHA2Digest: sha2_digest_sql,
         }
 
         RESERVED_KEYWORDS = {
@@ -606,6 +612,31 @@ class Presto(Dialect):
             "with",
         }
 
+        def extract_sql(self, expression: exp.Extract) -> str:
+            date_part = expression.name
+
+            if not date_part.startswith("EPOCH"):
+                return super().extract_sql(expression)
+
+            if date_part == "EPOCH_MILLISECOND":
+                scale = 10**3
+            elif date_part == "EPOCH_MICROSECOND":
+                scale = 10**6
+            elif date_part == "EPOCH_NANOSECOND":
+                scale = 10**9
+            else:
+                scale = None
+
+            value = expression.expression
+
+            ts = exp.cast(value, to=exp.DataType.build("TIMESTAMP"))
+            to_unix: exp.Expression = exp.TimeToUnix(this=ts)
+
+            if scale:
+                to_unix = exp.Mul(this=to_unix, expression=exp.Literal.number(scale))
+
+            return self.sql(to_unix)
+
         def jsonformat_sql(self, expression: exp.JSONFormat) -> str:
             this = expression.this
             is_json = expression.args.get("is_json")

sqlglot/dialects/redshift.py

@@ -47,6 +47,8 @@ class Redshift(Postgres):
     COPY_PARAMS_ARE_CSV = False
     HEX_LOWERCASE = True
     HAS_DISTINCT_ARRAY_CONSTRUCTORS = True
+    COALESCE_COMPARISON_NON_STANDARD = True
+    REGEXP_EXTRACT_POSITION_OVERFLOW_RETURNS_NULL = False
 
     # ref: https://docs.aws.amazon.com/redshift/latest/dg/r_FORMAT_strings.html
     TIME_FORMAT = "'YYYY-MM-DD HH24:MI:SS'"
@@ -68,6 +70,13 @@ class Redshift(Postgres):
             "DATE_DIFF": _build_date_delta(exp.TsOrDsDiff),
             "GETDATE": exp.CurrentTimestamp.from_arg_list,
             "LISTAGG": exp.GroupConcat.from_arg_list,
+            "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),
+            ),
             "SPLIT_TO_ARRAY": lambda args: exp.StringToArray(
                 this=seq_get(args, 0), expression=seq_get(args, 1) or exp.Literal.string(",")
             ),
@@ -200,6 +209,7 @@ class Redshift(Postgres):
             exp.JSONExtractScalar: json_extract_segments("JSON_EXTRACT_PATH_TEXT"),
             exp.GroupConcat: rename_func("LISTAGG"),
             exp.Hex: lambda self, e: self.func("UPPER", self.func("TO_HEX", self.sql(e, "this"))),
+            exp.RegexpExtract: rename_func("REGEXP_SUBSTR"),
             exp.Select: transforms.preprocess(
                 [
                     transforms.eliminate_window_clause,
@@ -218,6 +228,9 @@ class Redshift(Postgres):
             exp.TsOrDsAdd: date_delta_sql("DATEADD"),
             exp.TsOrDsDiff: date_delta_sql("DATEDIFF"),
             exp.UnixToTime: lambda self, e: self._unix_to_time_sql(e),
+            exp.SHA2Digest: lambda self, e: self.func(
+                "SHA2", e.this, e.args.get("length") or exp.Literal.number(256)
+            ),
         }
 
         # Postgres maps exp.Pivot to no_pivot_sql, but Redshift support pivots
@@ -231,6 +244,9 @@ class Redshift(Postgres):
         TRANSFORMS.pop(exp.LastDay)
         TRANSFORMS.pop(exp.SHA2)
 
+        # Postgres does not permit a double precision argument in ROUND; Redshift does
+        TRANSFORMS.pop(exp.Round)
+
         RESERVED_KEYWORDS = {
             "aes128",
             "aes256",

sqlglot/dialects/risingwave.py

@@ -8,6 +8,9 @@ from sqlglot import exp
 
 
 class RisingWave(Postgres):
+    REQUIRES_PARENTHESIZED_STRUCT_ACCESS = True
+    SUPPORTS_STRUCT_STAR_EXPANSION = True
+
     class Tokenizer(Postgres.Tokenizer):
         KEYWORDS = {
             **Postgres.Tokenizer.KEYWORDS,

sqlglot/dialects/singlestore.py

@@ -81,6 +81,7 @@ class SingleStore(MySQL):
             "!:>": TokenType.NCOLON_GT,
             "::$": TokenType.DCOLONDOLLAR,
             "::%": TokenType.DCOLONPERCENT,
+            "::?": TokenType.DCOLONQMARK,
         }
 
     class Parser(MySQL.Parser):
@@ -253,6 +254,12 @@ class SingleStore(MySQL):
             TokenType.DCOLONPERCENT: lambda self, this, path: build_json_extract_path(
                 exp.JSONExtractScalar, json_type="DOUBLE"
             )([this, exp.Literal.string(path.name)]),
+            TokenType.DCOLONQMARK: lambda self, this, path: self.expression(
+                exp.JSONExists,
+                this=this,
+                path=path.name,
+                from_dcolonqmark=True,
+            ),
         }
         COLUMN_OPERATORS.pop(TokenType.ARROW)
         COLUMN_OPERATORS.pop(TokenType.DARROW)
@@ -452,8 +459,10 @@ class SingleStore(MySQL):
             exp.JSONBExists: lambda self, e: self.func(
                 "BSON_MATCH_ANY_EXISTS", e.this, e.args.get("path")
             ),
-            exp.JSONExists: unsupported_args("passing", "on_condition")(
-                lambda self, e: self.func("JSON_MATCH_ANY_EXISTS", e.this, e.args.get("path"))
+            exp.JSONExists: lambda self, e: (
+                f"{self.sql(e.this)}::?{self.sql(e.args.get('path'))}"
+                if e.args.get("from_dcolonqmark")
+                else self.func("JSON_MATCH_ANY_EXISTS", e.this, e.args.get("path"))
             ),
             exp.JSONObject: unsupported_args(
                 "null_handling", "unique_keys", "return_type", "encoding"
@@ -542,7 +551,7 @@ class SingleStore(MySQL):
                 "offset",
                 "starts_with",
                 "limit",
-                "from",
+                "from_",
                 "scope",
                 "scope_kind",
                 "mutex",