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

sqlglot/_version.py

@@ -1,7 +1,14 @@
 # file generated by setuptools-scm
 # don't change, don't track in version control
 
-__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
 
 TYPE_CHECKING = False
 if TYPE_CHECKING:
@@ -9,13 +16,19 @@ if TYPE_CHECKING:
     from typing import Union
 
     VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
 else:
     VERSION_TUPLE = object
+    COMMIT_ID = object
 
 version: str
 __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
 
-__version__ = version = '27.7.0'
-__version_tuple__ = version_tuple = (27, 7, 0)
+__version__ = version = '27.8.0'
+__version_tuple__ = version_tuple = (27, 8, 0)
+
+__commit_id__ = commit_id = None

sqlglot/dialects/bigquery.py

@@ -4,7 +4,7 @@ import logging
 import re
 import typing as t
 
-from sqlglot import exp, generator, parser, tokens, transforms
+from sqlglot import exp, generator, jsonpath, parser, tokens, transforms
 from sqlglot._typing import E
 from sqlglot.dialects.dialect import (
     Dialect,
@@ -30,7 +30,6 @@ from sqlglot.dialects.dialect import (
     unit_to_var,
     strposition_sql,
     groupconcat_sql,
-    space_sql,
 )
 from sqlglot.helper import seq_get, split_num_words
 from sqlglot.tokens import TokenType
@@ -474,6 +473,8 @@ class BigQuery(Dialect):
                 exp.Substring,
             )
         },
+        exp.ArgMax: lambda self, e: self._annotate_by_args(e, "this"),
+        exp.ArgMin: lambda self, e: self._annotate_by_args(e, "this"),
         exp.Array: _annotate_array,
         exp.ArrayConcat: lambda self, e: self._annotate_by_args(e, "this", "expressions"),
         exp.Ascii: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
@@ -495,6 +496,7 @@ class BigQuery(Dialect):
         exp.GenerateTimestampArray: lambda self, e: self._annotate_with_type(
             e, exp.DataType.build("ARRAY<TIMESTAMP>", dialect="bigquery")
         ),
+        exp.Grouping: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
         exp.JSONArray: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.JSON),
         exp.JSONExtractScalar: lambda self, e: self._annotate_with_type(
             e, exp.DataType.Type.VARCHAR
@@ -504,9 +506,13 @@ class BigQuery(Dialect):
         ),
         exp.JSONType: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.VARCHAR),
         exp.Lag: lambda self, e: self._annotate_by_args(e, "this", "default"),
+        exp.MD5Digest: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BINARY),
         exp.ParseTime: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.TIME),
         exp.ParseDatetime: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.DATETIME),
+        exp.RegexpExtractAll: lambda self, e: self._annotate_by_args(e, "this", array=True),
+        exp.Replace: lambda self, e: self._annotate_by_args(e, "this"),
         exp.Reverse: lambda self, e: self._annotate_by_args(e, "this"),
+        exp.Soundex: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.VARCHAR),
         exp.SHA: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BINARY),
         exp.SHA2: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BINARY),
         exp.Sign: lambda self, e: self._annotate_by_args(e, "this"),
@@ -518,6 +524,7 @@ class BigQuery(Dialect):
         exp.TimeFromParts: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.TIME),
         exp.TsOrDsToTime: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.TIME),
         exp.TimeTrunc: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.TIME),
+        exp.Translate: lambda self, e: self._annotate_by_args(e, "this"),
         exp.Unicode: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BIGINT),
     }
 
@@ -550,6 +557,12 @@ class BigQuery(Dialect):
 
         return super().normalize_identifier(expression)
 
+    class JSONPathTokenizer(jsonpath.JSONPathTokenizer):
+        VAR_TOKENS = {
+            TokenType.DASH,
+            TokenType.VAR,
+        }
+
     class Tokenizer(tokens.Tokenizer):
         QUOTES = ["'", '"', '"""', "'''"]
         COMMENTS = ["--", "#", ("/*", "*/")]
@@ -1019,6 +1032,8 @@ class BigQuery(Dialect):
         EXCEPT_INTERSECT_SUPPORT_ALL_CLAUSE = False
         SUPPORTS_UNIX_SECONDS = True
 
+        SAFE_JSON_PATH_KEY_RE = re.compile(r"^[_\-a-zA-Z][\-\w]*$")
+
         TS_OR_DS_TYPES = (
             exp.TsOrDsToDatetime,
             exp.TsOrDsToTimestamp,
@@ -1107,7 +1122,6 @@ class BigQuery(Dialect):
             ),
             exp.SHA: rename_func("SHA1"),
             exp.SHA2: sha256_sql,
-            exp.Space: space_sql,
             exp.StabilityProperty: lambda self, e: (
                 "DETERMINISTIC" if e.name == "IMMUTABLE" else "NOT DETERMINISTIC"
             ),

sqlglot/dialects/databricks.py

@@ -99,7 +99,11 @@ class Databricks(Spark):
             exp.JSONExtract: _jsonextract_sql,
             exp.JSONExtractScalar: _jsonextract_sql,
             exp.JSONPathRoot: lambda *_: "",
-            exp.ToChar: lambda self, e: self.function_fallback_sql(e),
+            exp.ToChar: lambda self, e: (
+                self.cast_sql(exp.Cast(this=e.this, to=exp.DataType(this="STRING")))
+                if e.args.get("is_numeric")
+                else self.function_fallback_sql(e)
+            ),
         }
 
         TRANSFORMS.pop(exp.TryCast)

sqlglot/dialects/dialect.py

@@ -35,8 +35,18 @@ DATE_ADD_OR_DIFF = t.Union[
     exp.TsOrDsDiff,
 ]
 DATE_ADD_OR_SUB = t.Union[exp.DateAdd, exp.TsOrDsAdd, exp.DateSub]
-JSON_EXTRACT_TYPE = t.Union[exp.JSONExtract, exp.JSONExtractScalar]
-
+JSON_EXTRACT_TYPE = t.Union[
+    exp.JSONExtract, exp.JSONExtractScalar, exp.JSONBExtract, exp.JSONBExtractScalar
+]
+DATETIME_DELTA = t.Union[
+    exp.DateAdd,
+    exp.DatetimeAdd,
+    exp.DatetimeSub,
+    exp.TimeAdd,
+    exp.TimeSub,
+    exp.TimestampSub,
+    exp.TsOrDsAdd,
+]
 
 if t.TYPE_CHECKING:
     from sqlglot._typing import B, E, F
@@ -1059,7 +1069,9 @@ class Dialect(metaclass=_Dialect):
             try:
                 return parse_json_path(path_text, self)
             except ParseError as e:
-                if self.STRICT_JSON_PATH_SYNTAX:
+                if self.STRICT_JSON_PATH_SYNTAX and not path_text.lstrip().startswith(
+                    ("lax", "strict")
+                ):
                     logger.warning(f"Invalid JSON path syntax. {str(e)}")
 
         return path
@@ -1643,14 +1655,49 @@ def date_delta_sql(name: str, cast: bool = False) -> t.Callable[[Generator, DATE
     return _delta_sql
 
 
+def date_delta_to_binary_interval_op(
+    cast: bool = True,
+) -> t.Callable[[Generator, DATETIME_DELTA], str]:
+    def date_delta_to_binary_interval_op_sql(self: Generator, expression: DATETIME_DELTA) -> str:
+        this = expression.this
+        unit = unit_to_var(expression)
+        op = (
+            "+"
+            if isinstance(expression, (exp.DateAdd, exp.TimeAdd, exp.DatetimeAdd, exp.TsOrDsAdd))
+            else "-"
+        )
+
+        to_type: t.Optional[exp.DATA_TYPE] = None
+        if cast:
+            if isinstance(expression, exp.TsOrDsAdd):
+                to_type = expression.return_type
+            elif this.is_string:
+                # Cast string literals (i.e function parameters) to the appropriate type for +/- interval to work
+                to_type = (
+                    exp.DataType.Type.DATETIME
+                    if isinstance(expression, (exp.DatetimeAdd, exp.DatetimeSub))
+                    else exp.DataType.Type.DATE
+                )
+
+        this = exp.cast(this, to_type) if to_type else this
+
+        expr = expression.expression
+        interval = expr if isinstance(expr, exp.Interval) else exp.Interval(this=expr, unit=unit)
+
+        return f"{self.sql(this)} {op} {self.sql(interval)}"
+
+    return date_delta_to_binary_interval_op_sql
+
+
 def unit_to_str(expression: exp.Expression, default: str = "DAY") -> t.Optional[exp.Expression]:
     unit = expression.args.get("unit")
+    if not unit:
+        return exp.Literal.string(default) if default else None
 
-    if isinstance(unit, exp.Placeholder):
+    if isinstance(unit, exp.Placeholder) or type(unit) not in (exp.Var, exp.Literal):
         return unit
-    if unit:
-        return exp.Literal.string(unit.name)
-    return exp.Literal.string(default) if default else None
+
+    return exp.Literal.string(unit.name)
 
 
 def unit_to_var(expression: exp.Expression, default: str = "DAY") -> t.Optional[exp.Expression]:
@@ -1730,7 +1777,10 @@ def merge_without_target_sql(self: Generator, expression: exp.Merge) -> str:
 
 
 def build_json_extract_path(
-    expr_type: t.Type[F], zero_based_indexing: bool = True, arrow_req_json_type: bool = False
+    expr_type: t.Type[F],
+    zero_based_indexing: bool = True,
+    arrow_req_json_type: bool = False,
+    json_type: t.Optional[str] = None,
 ) -> t.Callable[[t.List], F]:
     def _builder(args: t.List) -> F:
         segments: t.List[exp.JSONPathPart] = [exp.JSONPathRoot()]
@@ -1750,11 +1800,19 @@ def build_json_extract_path(
 
         # This is done to avoid failing in the expression validator due to the arg count
         del args[2:]
-        return expr_type(
-            this=seq_get(args, 0),
-            expression=exp.JSONPath(expressions=segments),
-            only_json_types=arrow_req_json_type,
-        )
+        kwargs = {
+            "this": seq_get(args, 0),
+            "expression": exp.JSONPath(expressions=segments),
+        }
+
+        is_jsonb = issubclass(expr_type, (exp.JSONBExtract, exp.JSONBExtractScalar))
+        if not is_jsonb:
+            kwargs["only_json_types"] = arrow_req_json_type
+
+        if json_type is not None:
+            kwargs["json_type"] = json_type
+
+        return expr_type(**kwargs)
 
     return _builder
 
@@ -1962,7 +2020,7 @@ def groupconcat_sql(
     return self.sql(listagg)
 
 
-def build_timetostr_or_tochar(args: t.List, dialect: Dialect) -> exp.TimeToStr | exp.ToChar:
+def build_timetostr_or_tochar(args: t.List, dialect: DialectType) -> exp.TimeToStr | exp.ToChar:
     if len(args) == 2:
         this = args[0]
         if not this.type:
@@ -1983,12 +2041,3 @@ def build_replace_with_optional_replacement(args: t.List) -> exp.Replace:
         expression=seq_get(args, 1),
         replacement=seq_get(args, 2) or exp.Literal.string(""),
     )
-
-
-def space_sql(self: Generator, expression: exp.Space) -> str:
-    return self.sql(
-        exp.Repeat(
-            this=exp.Literal.string(" "),
-            times=expression.this,
-        )
-    )

sqlglot/dialects/dremio.py

@@ -1,14 +1,22 @@
 from __future__ import annotations
 
+import typing as t
+
 from sqlglot import expressions as exp
 from sqlglot import parser, generator, tokens
-from sqlglot.dialects.dialect import Dialect, build_formatted_time, unit_to_var
-import typing as t
+from sqlglot.dialects.dialect import (
+    Dialect,
+    build_timetostr_or_tochar,
+    build_formatted_time,
+    rename_func,
+    unit_to_var,
+)
+from sqlglot.helper import seq_get
+
+if t.TYPE_CHECKING:
+    from sqlglot.dialects.dialect import DialectType
 
-DATE_DELTA = t.Union[
-    exp.DateAdd,
-    exp.DateSub,
-]
+DATE_DELTA = t.Union[exp.DateAdd, exp.DateSub]
 
 
 def _date_delta_sql(name: str) -> t.Callable[[Dremio.Generator, DATE_DELTA], str]:
@@ -31,6 +39,17 @@ def _date_delta_sql(name: str) -> t.Callable[[Dremio.Generator, DATE_DELTA], str
     return _delta_sql
 
 
+def to_char_is_numeric_handler(args: t.List, dialect: DialectType) -> exp.TimeToStr | exp.ToChar:
+    expression = build_timetostr_or_tochar(args, dialect)
+    fmt = seq_get(args, 1)
+
+    if fmt and isinstance(expression, exp.ToChar) and fmt.is_string and "#" in fmt.name:
+        # Only mark as numeric if format is a literal containing #
+        expression.set("is_numeric", True)
+
+    return expression
+
+
 class Dremio(Dialect):
     SUPPORTS_USER_DEFINED_TYPES = False
     CONCAT_COALESCE = True
@@ -94,7 +113,9 @@ class Dremio(Dialect):
 
         FUNCTIONS = {
             **parser.Parser.FUNCTIONS,
-            "TO_CHAR": build_formatted_time(exp.TimeToStr, "dremio"),
+            "TO_CHAR": to_char_is_numeric_handler,
+            "DATE_FORMAT": build_formatted_time(exp.TimeToStr, "dremio"),
+            "TO_DATE": build_formatted_time(exp.TsOrDsToDate, "dremio"),
         }
 
     class Generator(generator.Generator):
@@ -123,8 +144,8 @@ class Dremio(Dialect):
 
         TRANSFORMS = {
             **generator.Generator.TRANSFORMS,
+            exp.ToChar: rename_func("TO_CHAR"),
             exp.TimeToStr: lambda self, e: self.func("TO_CHAR", e.this, self.format_time(e)),
-            exp.ToChar: lambda self, e: self.function_fallback_sql(e),
             exp.DateAdd: _date_delta_sql("DATE_ADD"),
             exp.DateSub: _date_delta_sql("DATE_SUB"),
         }

sqlglot/dialects/duckdb.py

@@ -4,7 +4,6 @@ import typing as t
 
 from sqlglot import exp, generator, parser, tokens, transforms
 
-from sqlglot.expressions import DATA_TYPE
 from sqlglot.dialects.dialect import (
     Dialect,
     JSON_EXTRACT_TYPE,
@@ -16,6 +15,7 @@ from sqlglot.dialects.dialect import (
     bool_xor_sql,
     build_default_decimal_type,
     count_if_to_sum,
+    date_delta_to_binary_interval_op,
     date_trunc_to_time,
     datestrtodate_sql,
     no_datetime_sql,
@@ -32,7 +32,6 @@ from sqlglot.dialects.dialect import (
     str_to_time_sql,
     timestamptrunc_sql,
     timestrtotime_sql,
-    unit_to_var,
     unit_to_str,
     sha256_sql,
     build_regexp_extract,
@@ -45,38 +44,6 @@ from sqlglot.helper import seq_get
 from sqlglot.tokens import TokenType
 from sqlglot.parser import binary_range_parser
 
-DATETIME_DELTA = t.Union[
-    exp.DateAdd, exp.TimeAdd, exp.DatetimeAdd, exp.TsOrDsAdd, exp.DateSub, exp.DatetimeSub
-]
-
-
-def _date_delta_sql(self: DuckDB.Generator, expression: DATETIME_DELTA) -> str:
-    this = expression.this
-    unit = unit_to_var(expression)
-    op = (
-        "+"
-        if isinstance(expression, (exp.DateAdd, exp.TimeAdd, exp.DatetimeAdd, exp.TsOrDsAdd))
-        else "-"
-    )
-
-    to_type: t.Optional[DATA_TYPE] = None
-    if isinstance(expression, exp.TsOrDsAdd):
-        to_type = expression.return_type
-    elif this.is_string:
-        # Cast string literals (i.e function parameters) to the appropriate type for +/- interval to work
-        to_type = (
-            exp.DataType.Type.DATETIME
-            if isinstance(expression, (exp.DatetimeAdd, exp.DatetimeSub))
-            else exp.DataType.Type.DATE
-        )
-
-    this = exp.cast(this, to_type) if to_type else this
-
-    expr = expression.expression
-    interval = expr if isinstance(expr, exp.Interval) else exp.Interval(this=expr, unit=unit)
-
-    return f"{self.sql(this)} {op} {self.sql(interval)}"
-
 
 # BigQuery -> DuckDB conversion for the DATE function
 def _date_sql(self: DuckDB.Generator, expression: exp.Date) -> str:
@@ -687,14 +654,14 @@ class DuckDB(Dialect):
             exp.DayOfYear: rename_func("DAYOFYEAR"),
             exp.DataType: _datatype_sql,
             exp.Date: _date_sql,
-            exp.DateAdd: _date_delta_sql,
+            exp.DateAdd: date_delta_to_binary_interval_op(),
             exp.DateFromParts: rename_func("MAKE_DATE"),
-            exp.DateSub: _date_delta_sql,
+            exp.DateSub: date_delta_to_binary_interval_op(),
             exp.DateDiff: _date_diff_sql,
             exp.DateStrToDate: datestrtodate_sql,
             exp.Datetime: no_datetime_sql,
-            exp.DatetimeSub: _date_delta_sql,
-            exp.DatetimeAdd: _date_delta_sql,
+            exp.DatetimeSub: date_delta_to_binary_interval_op(),
+            exp.DatetimeAdd: date_delta_to_binary_interval_op(),
             exp.DateToDi: lambda self,
             e: f"CAST(STRFTIME({self.sql(e, 'this')}, {DuckDB.DATEINT_FORMAT}) AS INT)",
             exp.Decode: lambda self, e: encode_decode_sql(self, e, "DECODE", replace=False),
@@ -756,7 +723,7 @@ class DuckDB(Dialect):
             ),
             exp.Struct: _struct_sql,
             exp.Transform: rename_func("LIST_TRANSFORM"),
-            exp.TimeAdd: _date_delta_sql,
+            exp.TimeAdd: date_delta_to_binary_interval_op(),
             exp.Time: no_time_sql,
             exp.TimeDiff: _timediff_sql,
             exp.Timestamp: no_timestamp_sql,
@@ -773,7 +740,7 @@ class DuckDB(Dialect):
             exp.TimeToUnix: rename_func("EPOCH"),
             exp.TsOrDiToDi: lambda self,
             e: f"CAST(SUBSTR(REPLACE(CAST({self.sql(e, 'this')} AS TEXT), '-', ''), 1, 8) AS INT)",
-            exp.TsOrDsAdd: _date_delta_sql,
+            exp.TsOrDsAdd: date_delta_to_binary_interval_op(),
             exp.TsOrDsDiff: lambda self, e: self.func(
                 "DATE_DIFF",
                 f"'{e.args.get('unit') or 'DAY'}'",

sqlglot/dialects/exasol.py

@@ -109,6 +109,7 @@ class Exasol(Dialect):
             "ENDIF": TokenType.END,
             "LONG VARCHAR": TokenType.TEXT,
         }
+        KEYWORDS.pop("DIV")
 
     class Parser(parser.Parser):
         FUNCTIONS = {
@@ -131,6 +132,7 @@ class Exasol(Dialect):
             "DATE_TRUNC": lambda args: exp.TimestampTrunc(
                 this=seq_get(args, 1), unit=seq_get(args, 0)
             ),
+            "DIV": binary_from_function(exp.IntDiv),
             "EVERY": lambda args: exp.All(this=seq_get(args, 0)),
             "EDIT_DISTANCE": exp.Levenshtein.from_arg_list,
             "HASH_SHA": exp.SHA.from_arg_list,
@@ -228,6 +230,8 @@ class Exasol(Dialect):
             # https://docs.exasol.com/db/latest/sql_references/functions/alphabeticallistfunctions/bit_xor.htm
             exp.BitwiseXor: rename_func("BIT_XOR"),
             exp.DateDiff: _date_diff_sql,
+            # https://docs.exasol.com/db/latest/sql_references/functions/alphabeticallistfunctions/div.htm#DIV
+            exp.IntDiv: rename_func("DIV"),
             exp.TsOrDsDiff: _date_diff_sql,
             exp.DateTrunc: lambda self, e: self.func("TRUNC", e.this, unit_to_str(e)),
             exp.DatetimeTrunc: timestamptrunc_sql(),
@@ -280,6 +284,7 @@ class Exasol(Dialect):
             exp.MD5Digest: rename_func("HASHTYPE_MD5"),
             # https://docs.exasol.com/db/latest/sql/create_view.htm
             exp.CommentColumnConstraint: lambda self, e: f"COMMENT IS {self.sql(e, 'this')}",
+            exp.WeekOfYear: rename_func("WEEK"),
         }
 
         def converttimezone_sql(self, expression: exp.ConvertTimezone) -> str:

sqlglot/dialects/mysql.py

@@ -709,21 +709,6 @@ class MySQL(Dialect):
 
             return self.expression(exp.GroupConcat, this=this, separator=separator)
 
-        def _parse_json_value(self) -> exp.JSONValue:
-            this = self._parse_bitwise()
-            self._match(TokenType.COMMA)
-            path = self._parse_bitwise()
-
-            returning = self._match(TokenType.RETURNING) and self._parse_type()
-
-            return self.expression(
-                exp.JSONValue,
-                this=this,
-                path=self.dialect.to_json_path(path),
-                returning=returning,
-                on_condition=self._parse_on_condition(),
-            )
-
         def _parse_alter_table_alter_index(self) -> exp.AlterIndex:
             index = self._parse_field(any_token=True)
 

sqlglot/dialects/presto.py

@@ -31,7 +31,6 @@ from sqlglot.dialects.dialect import (
     sequence_sql,
     build_regexp_extract,
     explode_to_unnest_sql,
-    space_sql,
 )
 from sqlglot.dialects.hive import Hive
 from sqlglot.dialects.mysql import MySQL
@@ -506,7 +505,6 @@ class Presto(Dialect):
                     amend_exploded_column_table,
                 ]
             ),
-            exp.Space: space_sql,
             exp.SortArray: _no_sort_array,
             exp.StrPosition: lambda self, e: strposition_sql(self, e, supports_occurrence=True),
             exp.StrToDate: lambda self, e: f"CAST({_str_to_time_sql(self, e)} AS DATE)",

sqlglot/dialects/singlestore.py

@@ -2,7 +2,13 @@ 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,
+)
 from sqlglot.dialects.mysql import MySQL
 from sqlglot.generator import unsupported_args
 from sqlglot.helper import seq_get
@@ -66,6 +72,27 @@ class SingleStore(MySQL):
             ),
             "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"
+            ),
+            "DATE": exp.Date.from_arg_list,
         }
 
         CAST_COLUMN_OPERATORS = {TokenType.COLON_GT, TokenType.NCOLON_GT}
@@ -81,9 +108,24 @@ 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)),
@@ -107,6 +149,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 +181,29 @@ 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 *_: "",
         }
+        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 = {
@@ -1193,3 +1258,31 @@ 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)

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/expressions.py

@@ -5301,7 +5301,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()
             )
@@ -5464,6 +5464,15 @@ 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 +5540,12 @@ 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,
+    }
 
 
 # https://docs.snowflake.com/en/sql-reference/functions/to_decimal
@@ -6508,7 +6522,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 +6542,7 @@ class JSONBExtract(Binary, Func):
 
 
 class JSONBExtractScalar(Binary, Func):
+    arg_types = {"this": True, "expression": True, "json_type": False}
     _sql_names = ["JSONB_EXTRACT_SCALAR"]
 
 
@@ -6841,6 +6862,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}
 

sqlglot/generator.py

@@ -692,6 +692,8 @@ class Generator(metaclass=_Generator):
 
     RESPECT_IGNORE_NULLS_UNSUPPORTED_EXPRESSIONS: t.Tuple[t.Type[exp.Expression], ...] = ()
 
+    SAFE_JSON_PATH_KEY_RE = exp.SAFE_IDENTIFIER_RE
+
     SENTINEL_LINE_BREAK = "__SQLGLOT__LB__"
 
     __slots__ = (
@@ -4362,7 +4364,7 @@ class Generator(metaclass=_Generator):
             this = self.json_path_part(this)
             return f".{this}" if this else ""
 
-        if exp.SAFE_IDENTIFIER_RE.match(this):
+        if self.SAFE_JSON_PATH_KEY_RE.match(this):
             return f".{this}"
 
         this = self.json_path_part(this)
@@ -5146,3 +5148,6 @@ class Generator(metaclass=_Generator):
                 unit=exp.var("DAY"),
             )
         )
+
+    def space_sql(self: Generator, expression: exp.Space) -> str:
+        return self.sql(exp.Repeat(this=exp.Literal.string(" "), times=expression.this))

sqlglot/jsonpath.py

@@ -36,6 +36,10 @@ class JSONPathTokenizer(Tokenizer):
     IDENTIFIER_ESCAPES = ["\\"]
     STRING_ESCAPES = ["\\"]
 
+    VAR_TOKENS = {
+        TokenType.VAR,
+    }
+
 
 def parse(path: str, dialect: DialectType = None) -> exp.JSONPath:
     """Takes in a JSON path string and parses it into a JSONPath expression."""
@@ -76,6 +80,9 @@ def parse(path: str, dialect: DialectType = None) -> exp.JSONPath:
             raise ParseError(_error(f"Expected {token_type}"))
         return None
 
+    def _match_set(types: t.Collection[TokenType]) -> t.Optional[Token]:
+        return _advance() if _curr() in types else None
+
     def _parse_literal() -> t.Any:
         token = _match(TokenType.STRING) or _match(TokenType.IDENTIFIER)
         if token:
@@ -155,7 +162,7 @@ def parse(path: str, dialect: DialectType = None) -> exp.JSONPath:
         """
         prev_index = i - 2
 
-        while _match(TokenType.VAR):
+        while _match_set(jsonpath_tokenizer.VAR_TOKENS):
             pass
 
         start = 0 if prev_index < 0 else tokens[prev_index].end + 1
@@ -177,7 +184,7 @@ def parse(path: str, dialect: DialectType = None) -> exp.JSONPath:
         if _match(TokenType.DOT) or _match(TokenType.COLON):
             recursive = _prev().text == ".."
 
-            if _match(TokenType.VAR):
+            if _match_set(jsonpath_tokenizer.VAR_TOKENS):
                 value: t.Optional[str | exp.JSONPathWildcard] = _parse_var_text()
             elif _match(TokenType.IDENTIFIER):
                 value = _prev().text
@@ -194,7 +201,7 @@ def parse(path: str, dialect: DialectType = None) -> exp.JSONPath:
                 raise ParseError(_error("Expected key name or * after DOT"))
         elif _match(TokenType.L_BRACKET):
             expressions.append(_parse_bracket())
-        elif _match(TokenType.VAR):
+        elif _match_set(jsonpath_tokenizer.VAR_TOKENS):
             expressions.append(exp.JSONPathKey(this=_parse_var_text()))
         elif _match(TokenType.IDENTIFIER):
             expressions.append(exp.JSONPathKey(this=_prev().text))

sqlglot/parser.py

@@ -577,7 +577,6 @@ class Parser(metaclass=_Parser):
 
     TABLE_ALIAS_TOKENS = ID_VAR_TOKENS - {
         TokenType.ANTI,
-        TokenType.APPLY,
         TokenType.ASOF,
         TokenType.FULL,
         TokenType.LEFT,
@@ -8708,3 +8707,18 @@ class Parser(metaclass=_Parser):
             kwargs["requires_string"] = self.dialect.TRY_CAST_REQUIRES_STRING
 
         return self.expression(exp_class, **kwargs)
+
+    def _parse_json_value(self) -> exp.JSONValue:
+        this = self._parse_bitwise()
+        self._match(TokenType.COMMA)
+        path = self._parse_bitwise()
+
+        returning = self._match(TokenType.RETURNING) and self._parse_type()
+
+        return self.expression(
+            exp.JSONValue,
+            this=this,
+            path=self.dialect.to_json_path(path),
+            returning=returning,
+            on_condition=self._parse_on_condition(),
+        )

{sqlglot-27.7.0.dist-info → sqlglot-27.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlglot
-Version: 27.7.0
+Version: 27.8.0
 Summary: An easily customizable SQL parser and transpiler
 Author-email: Toby Mao <toby.mao@gmail.com>
 Project-URL: Homepage, https://sqlglot.com/
@@ -256,7 +256,7 @@ sqlglot.errors.ParseError: Expecting ). Line 1, Col: 34.
 Structured syntax errors are accessible for programmatic use:
 
 ```python
-import sqlglot
+import sqlglot.errors
 try:
     sqlglot.transpile("SELECT foo FROM (SELECT baz FROM t")
 except sqlglot.errors.ParseError as e:

{sqlglot-27.7.0.dist-info → sqlglot-27.8.0.dist-info}/RECORD

@@ -1,15 +1,15 @@
 sqlglot/__init__.py,sha256=za08rtdPh2v7dOpGdNomttlIVGgTrKja7rPd6sQwaTg,5391
 sqlglot/__main__.py,sha256=022c173KqxsiABWTEpUIq_tJUxuNiW7a7ABsxBXqvu8,2069
 sqlglot/_typing.py,sha256=-1HPyr3w5COlSJWqlgt8jhFk2dyMvBuvVBqIX1wyVCM,642
-sqlglot/_version.py,sha256=5PUg50O7n_si_pQEvZg7Hxhtah6hzWUX8K6MSHG_oxc,513
+sqlglot/_version.py,sha256=6Bcdz-xEd_4XJzvpG14av5V0A6AT1_hYMo5MIczQYNw,706
 sqlglot/diff.py,sha256=PtOllQMQa1Sw1-V2Y8eypmDqGujXYPaTOp_WLsWkAWk,17314
 sqlglot/errors.py,sha256=QNKMr-pzLUDR-tuMmn_GK6iMHUIVdb_YSJ_BhGEvuso,2126
-sqlglot/expressions.py,sha256=Odk7emY-OtfIxyqDdhqgHM4m7AEvKGLo7nCDML2Y3Dw,247140
-sqlglot/generator.py,sha256=hXFm8cL3QTVHrUKz0vNK0PnymYHWxHk4Gzy_4bepjxg,219142
+sqlglot/expressions.py,sha256=qtKgdbejSFXnsDcIZ8XT6wR6EXrtru7U2G4edUyVzU4,247540
+sqlglot/generator.py,sha256=KXHnyJQKSq2Xy5RBDC-6GAW_zJqcNsHhZFV4P13l_iU,219354
 sqlglot/helper.py,sha256=9nZjFVRBtMKFC3EdzpDQ6jkazFO19po6BF8xHiNGZIo,15111
-sqlglot/jsonpath.py,sha256=jneO-A57n4ojVT2drCn2HBlx_Ka8wLcGpemW1JgvbjA,7666
+sqlglot/jsonpath.py,sha256=SQgaxzaEYBN7At9dkTK4N1Spk6xHxvHL6QtCIP6iM30,7905
 sqlglot/lineage.py,sha256=Qj5ykuDNcATppb9vOjoIKBqRVLbu3OMPiZk9f3iyv40,15312
-sqlglot/parser.py,sha256=Pt0uy-MgeTNYqwLMgiLhgB_hk2HlOJMFV1rDC-JrmlQ,328778
+sqlglot/parser.py,sha256=3DexBAzFLyrg4eEgNffcHB9d1ugwsxrFoZBWttRnmto,329221
 sqlglot/planner.py,sha256=ql7Li-bWJRcyXzNaZy_n6bQ6B2ZfunEIB8Ztv2xaxq4,14634
 sqlglot/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sqlglot/schema.py,sha256=13H2qKQs27EKdTpDLOvcNnSTDAUbYNKjWtJs4aQCSOA,20509
@@ -20,36 +20,36 @@ sqlglot/transforms.py,sha256=utNDsCBsA7hPUK3-aby3DDgiY_XVMAKQqeoLm1EyihI,41218
 sqlglot/trie.py,sha256=v27uXMrHfqrXlJ6GmeTSMovsB_3o0ctnlKhdNt7W6fI,2245
 sqlglot/dialects/__init__.py,sha256=BQUv9EuMmvhP_wVitGLo0PlCi15atvfXgvREpsTsxeQ,3799
 sqlglot/dialects/athena.py,sha256=ofArmayYLev4qZQ15GM8mevG04qqR5WGFb2ZcuYm6x4,10966
-sqlglot/dialects/bigquery.py,sha256=d9RdAVLTIgHaOYi6INMNQL38S_zagdl9vNbIL_Ds21c,58896
+sqlglot/dialects/bigquery.py,sha256=OAzuqTOGti3_US_oa0s0LWP56LjBaxTJ1B8tVZBgwVY,59733
 sqlglot/dialects/clickhouse.py,sha256=ygkVXh8fAxQ2sPvsDIP3y-1bUxV2PSLeS-983MI1uKs,57780
-sqlglot/dialects/databricks.py,sha256=mJN2lFpqgH95x3mtry3qWbuRf4q7NV5jbRAOspqclzY,4548
-sqlglot/dialects/dialect.py,sha256=g6gUxzNFXJYFDYkDJY314pup63-2OvGek2kdufEn59g,71267
+sqlglot/dialects/databricks.py,sha256=761qPlGOFHa9V8mdQYNAEw0pv4HUJYMkGEuFsdsLC7s,4714
+sqlglot/dialects/dialect.py,sha256=QXis6e9a0jX02QbtqpEKGXDY-gWa46EWOv14k9TE_zE,73001
 sqlglot/dialects/doris.py,sha256=HT3NyPORz8E1Kk6nNT00CEe4cwz1CfXGhhBcg8Hht1s,21709
-sqlglot/dialects/dremio.py,sha256=vOVu-L9QYLMV8gkbY6vfDh_iffhw3D58IKk0yqvd0Lo,4512
+sqlglot/dialects/dremio.py,sha256=opJ6QbsJJwhJRH4josxwkw28M_ABgP6zMY30-A6JFdg,5189
 sqlglot/dialects/drill.py,sha256=FOh7_KjPx_77pv0DiHKZog0CcmzqeF9_PEmGnJ1ESSM,5825
 sqlglot/dialects/druid.py,sha256=kh3snZtneehNOWqs3XcPjsrhNaRbkCQ8E4hHbWJ1fHM,690
-sqlglot/dialects/duckdb.py,sha256=kZ1LkGEtztkYwxh8Oad2GHUpmeM226h_uxSoCQ114Bo,52892
+sqlglot/dialects/duckdb.py,sha256=YUne3dZOD-nRlf_JGK5EcT_DJt9I0w7byeYuPcXvKvo,51894
 sqlglot/dialects/dune.py,sha256=gALut-fFfN2qMsr8LvZ1NQK3F3W9z2f4PwMvTMXVVVg,375
-sqlglot/dialects/exasol.py,sha256=w73rFG7jQVkBm2plWR8I12LMkHQVPofsEgWRf6VmiI8,14269
+sqlglot/dialects/exasol.py,sha256=vvoL5QcPF6eBoXuZF_iRc_VpF0OviRNjtWD0ER59xqI,14554
 sqlglot/dialects/fabric.py,sha256=4Sng2ZhQSaf6eK3ituR9DqDZERaVwYS_UfdpusjsISg,10220
 sqlglot/dialects/hive.py,sha256=bAZz0qnaOH9f5FyIMkqBu3XB2Cj7y-xnCPbxPsk8U9I,31959
 sqlglot/dialects/materialize.py,sha256=LD2q1kTRrCwkIu1BfoBvnjTGbupDtoQ8JQMDCIYAXHg,3533
-sqlglot/dialects/mysql.py,sha256=J_88qeXxC_oD09yMiNgw_so3x2QlaqL5l7CRku1R6wo,49280
+sqlglot/dialects/mysql.py,sha256=ds_dsTw1ZzsoW0tRbxpKOB9fVaIpXb9t1Hqa9n5MGX0,48764
 sqlglot/dialects/oracle.py,sha256=DpckKjR3FauVmXDIDaNTFqJE0KzXnW4sUlnZjQC8z0Y,15735
 sqlglot/dialects/postgres.py,sha256=8QF9uEXXFAGCXQah1n8mv4fonF58o0n59Il66hOZYqI,33942
-sqlglot/dialects/presto.py,sha256=Tm3Bx9AJilT1xlgunTpF0wUhIZBOPS-rB5Iwitnygxc,33462
+sqlglot/dialects/presto.py,sha256=XVeYr2NP86x5enlRqI7MYR6le85_ucYg_BBRocGN3jM,33413
 sqlglot/dialects/prql.py,sha256=fwN-SPEGx-drwf1K0U2MByN-PkW3C_rOgQ3xeJeychg,7908
 sqlglot/dialects/redshift.py,sha256=MXI9W7CgKCtMNjNRPcZPxO8NBA9_PxZx14HB52o-aUc,15822
 sqlglot/dialects/risingwave.py,sha256=BqWwW1iT_OIVMwfRamaww79snnBwIgCfr22Go-ggO68,3289
-sqlglot/dialects/singlestore.py,sha256=dJp28vf7e9j87U7wnJF7cmXul9sypY1dU0vjZx63Fkc,31363
+sqlglot/dialects/singlestore.py,sha256=FQzHqeFQd_nBisCIcUK4-4cbLr8bjnAcbVNN7LI7HPk,35533
 sqlglot/dialects/snowflake.py,sha256=XPsqYGBjn3dfddF2dcuM7Ur-4sYdthjW7cSPnptWq_s,70542
-sqlglot/dialects/spark.py,sha256=qVZ96NqRnj2YhphWoJhRJTcwmrmNfXD2g442tL3MTrs,8956
+sqlglot/dialects/spark.py,sha256=5dKMb9cGl0GMreEyFfjClvW1Cwm1JEx3W-hFnxjqW8E,9362
 sqlglot/dialects/spark2.py,sha256=aCwPqLduLRSUSPtbI1VtBjydK6haKgEy3iahmueGRo4,14742
 sqlglot/dialects/sqlite.py,sha256=XIDmiNTswWcrDwlFm8gOODCrJ_rPmXQKkm9U_-YAlVs,13183
 sqlglot/dialects/starrocks.py,sha256=2gav0PSNgRdAGXzawdznZliBpglJoQ0wBxPI7ZIMsRw,11314
 sqlglot/dialects/tableau.py,sha256=oIawDzUITxGCWaEMB8OaNMPWhbC3U-2y09pYPm4eazc,2190
 sqlglot/dialects/teradata.py,sha256=7LxCcRwP0Idd_OnCzA57NCdheVjHcKC2aFAKG5N49IU,18202
-sqlglot/dialects/trino.py,sha256=wgLsiX1NQvjGny_rgrU1e2r6kK1LD0KgaSdIDrYmjD0,4285
+sqlglot/dialects/trino.py,sha256=Z7prRhCxIBh0KCxIQpWmVOIGHCJM9Xl5oRlqySxln4Y,4350
 sqlglot/dialects/tsql.py,sha256=sz1t79iCcsMXw8PKYnKldZJbAQ2iobNsqLPVAj-QTXk,54036
 sqlglot/executor/__init__.py,sha256=FslewzYQtQdDNg_0Ju2UaiP4vo4IMUgkfkmFsYUhcN0,2958
 sqlglot/executor/context.py,sha256=WJHJdYQCOeVXwLw0uSSrWSc25eBMn5Ix108RCvdsKRQ,3386
@@ -76,8 +76,8 @@ sqlglot/optimizer/qualify_tables.py,sha256=dA4ZazL7ShQh2JgBwpHuG-4c5lBw1TNzCnuN7
 sqlglot/optimizer/scope.py,sha256=T6iVYnYwubt-WB1BOFsFYdJ-D7WtWZGL37SuCRQK23s,31154
 sqlglot/optimizer/simplify.py,sha256=-_yus42OYwqjQ9a2TSGhtG2G0pSkInUry1z7hEMz2pY,51062
 sqlglot/optimizer/unnest_subqueries.py,sha256=kzWUVDlxs8z9nmRx-8U-pHXPtVZhEIwkKqmKhr2QLvc,10908
-sqlglot-27.7.0.dist-info/licenses/LICENSE,sha256=p1Yk0B4oa0l8Rh-_dYyy75d8spjPd_vTloXfz4FWxys,1065
-sqlglot-27.7.0.dist-info/METADATA,sha256=hzW8lPG_bNI-kTX-iNRWj2ntlxyQRdHI-O3vUQU0_64,19437
-sqlglot-27.7.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sqlglot-27.7.0.dist-info/top_level.txt,sha256=5kRskCGA_gVADF9rSfSzPdLHXqvfMusDYeHePfNY2nQ,8
-sqlglot-27.7.0.dist-info/RECORD,,
+sqlglot-27.8.0.dist-info/licenses/LICENSE,sha256=p1Yk0B4oa0l8Rh-_dYyy75d8spjPd_vTloXfz4FWxys,1065
+sqlglot-27.8.0.dist-info/METADATA,sha256=wmjTJpMM7ieiqzI1z-VsjfHD7NH6NzBycgCo0Of-OgY,19444
+sqlglot-27.8.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sqlglot-27.8.0.dist-info/top_level.txt,sha256=5kRskCGA_gVADF9rSfSzPdLHXqvfMusDYeHePfNY2nQ,8
+sqlglot-27.8.0.dist-info/RECORD,,