sqlglot 26.31.0__py3-none-any.whl → 26.32.0__py3-none-any.whl

sqlglot/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '26.31.0'
-__version_tuple__ = version_tuple = (26, 31, 0)
+__version__ = version = '26.32.0'
+__version_tuple__ = version_tuple = (26, 32, 0)

sqlglot/dialects/__init__.py

@@ -70,6 +70,7 @@ DIALECTS = [
     "ClickHouse",
     "Databricks",
     "Doris",
+    "Dremio",
     "Drill",
     "Druid",
     "DuckDB",

sqlglot/dialects/athena.py

@@ -2,46 +2,218 @@ from __future__ import annotations
 
 import typing as t
 
-from sqlglot import exp
-from sqlglot.dialects.trino import Trino
-from sqlglot.dialects.hive import Hive
-from sqlglot.tokens import TokenType
+from sqlglot import exp, generator, parser, tokens
+from sqlglot.dialects import Dialect, Hive, Trino
+from sqlglot.tokens import TokenType, Token
+
+
+class Athena(Dialect):
+    """
+    Over the years, it looks like AWS has taken various execution engines, bolted on AWS-specific
+    modifications and then built the Athena service around them.
+
+    Thus, Athena is not simply hosted Trino, it's more like a router that routes SQL queries to an
+    execution engine depending on the query type.
+
+    As at 2024-09-10, assuming your Athena workgroup is configured to use "Athena engine version 3",
+    the following engines exist:
+
+    Hive:
+     - Accepts mostly the same syntax as Hadoop / Hive
+     - Uses backticks to quote identifiers
+     - Has a distinctive DDL syntax (around things like setting table properties, storage locations etc)
+       that is different from Trino
+     - Used for *most* DDL, with some exceptions that get routed to the Trino engine instead:
+        - CREATE [EXTERNAL] TABLE (without AS SELECT)
+        - ALTER
+        - DROP
+
+    Trino:
+      - Uses double quotes to quote identifiers
+      - Used for DDL operations that involve SELECT queries, eg:
+        - CREATE VIEW / DROP VIEW
+        - CREATE TABLE... AS SELECT
+      - Used for DML operations
+        - SELECT, INSERT, UPDATE, DELETE, MERGE
+
+    The SQLGlot Athena dialect tries to identify which engine a query would be routed to and then uses the
+    tokenizer / parser / generator for that engine. This is unfortunately necessary, as there are certain
+    incompatibilities between the engines' dialects and thus can't be handled by a single, unifying dialect.
+
+    References:
+    - https://docs.aws.amazon.com/athena/latest/ug/ddl-reference.html
+    - https://docs.aws.amazon.com/athena/latest/ug/dml-queries-functions-operators.html
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+        self._hive = Hive(**kwargs)
+        self._trino = Trino(**kwargs)
+
+    def tokenize(self, sql: str, **opts) -> t.List[Token]:
+        opts["hive"] = self._hive
+        opts["trino"] = self._trino
+        return super().tokenize(sql, **opts)
+
+    def parse(self, sql: str, **opts) -> t.List[t.Optional[exp.Expression]]:
+        opts["hive"] = self._hive
+        opts["trino"] = self._trino
+        return super().parse(sql, **opts)
+
+    def parse_into(
+        self, expression_type: exp.IntoType, sql: str, **opts
+    ) -> t.List[t.Optional[exp.Expression]]:
+        opts["hive"] = self._hive
+        opts["trino"] = self._trino
+        return super().parse_into(expression_type, sql, **opts)
+
+    def generate(self, expression: exp.Expression, copy: bool = True, **opts) -> str:
+        opts["hive"] = self._hive
+        opts["trino"] = self._trino
+        return super().generate(expression, copy=copy, **opts)
+
+    # This Tokenizer consumes a combination of HiveQL and Trino SQL and then processes the tokens
+    # to disambiguate which dialect needs to be actually used in order to tokenize correctly.
+    class Tokenizer(tokens.Tokenizer):
+        IDENTIFIERS = Trino.Tokenizer.IDENTIFIERS + Hive.Tokenizer.IDENTIFIERS
+        STRING_ESCAPES = Trino.Tokenizer.STRING_ESCAPES + Hive.Tokenizer.STRING_ESCAPES
+        HEX_STRINGS = Trino.Tokenizer.HEX_STRINGS + Hive.Tokenizer.HEX_STRINGS
+        UNICODE_STRINGS = Trino.Tokenizer.UNICODE_STRINGS + Hive.Tokenizer.UNICODE_STRINGS
+
+        NUMERIC_LITERALS = {
+            **Trino.Tokenizer.NUMERIC_LITERALS,
+            **Hive.Tokenizer.NUMERIC_LITERALS,
+        }
+
+        KEYWORDS = {
+            **Hive.Tokenizer.KEYWORDS,
+            **Trino.Tokenizer.KEYWORDS,
+            "UNLOAD": TokenType.COMMAND,
+        }
+
+        def __init__(self, *args: t.Any, **kwargs: t.Any) -> None:
+            hive = kwargs.pop("hive", None) or Hive()
+            trino = kwargs.pop("trino", None) or Trino()
+
+            super().__init__(*args, **kwargs)
+
+            self._hive_tokenizer = hive.tokenizer(*args, **{**kwargs, "dialect": hive})
+            self._trino_tokenizer = _TrinoTokenizer(*args, **{**kwargs, "dialect": trino})
+
+        def tokenize(self, sql: str) -> t.List[Token]:
+            tokens = super().tokenize(sql)
+
+            if _tokenize_as_hive(tokens):
+                return [Token(TokenType.HIVE_TOKEN_STREAM, "")] + self._hive_tokenizer.tokenize(sql)
+
+            return self._trino_tokenizer.tokenize(sql)
+
+    class Parser(parser.Parser):
+        def __init__(self, *args: t.Any, **kwargs: t.Any) -> None:
+            hive = kwargs.pop("hive", None) or Hive()
+            trino = kwargs.pop("trino", None) or Trino()
+
+            super().__init__(*args, **kwargs)
+
+            self._hive_parser = hive.parser(*args, **{**kwargs, "dialect": hive})
+            self._trino_parser = _TrinoParser(*args, **{**kwargs, "dialect": trino})
+
+        def parse(
+            self, raw_tokens: t.List[Token], sql: t.Optional[str] = None
+        ) -> t.List[t.Optional[exp.Expression]]:
+            if raw_tokens and raw_tokens[0].token_type == TokenType.HIVE_TOKEN_STREAM:
+                return self._hive_parser.parse(raw_tokens[1:], sql)
+
+            return self._trino_parser.parse(raw_tokens, sql)
+
+        def parse_into(
+            self,
+            expression_types: exp.IntoType,
+            raw_tokens: t.List[Token],
+            sql: t.Optional[str] = None,
+        ) -> t.List[t.Optional[exp.Expression]]:
+            if raw_tokens and raw_tokens[0].token_type == TokenType.HIVE_TOKEN_STREAM:
+                return self._hive_parser.parse_into(expression_types, raw_tokens[1:], sql)
+
+            return self._trino_parser.parse_into(expression_types, raw_tokens, sql)
+
+    class Generator(generator.Generator):
+        def __init__(self, *args: t.Any, **kwargs: t.Any) -> None:
+            hive = kwargs.pop("hive", None) or Hive()
+            trino = kwargs.pop("trino", None) or Trino()
+
+            super().__init__(*args, **kwargs)
+
+            self._hive_generator = _HiveGenerator(*args, **{**kwargs, "dialect": hive})
+            self._trino_generator = _TrinoGenerator(*args, **{**kwargs, "dialect": trino})
+
+        def generate(self, expression: exp.Expression, copy: bool = True) -> str:
+            if _generate_as_hive(expression):
+                generator = self._hive_generator
+            else:
+                generator = self._trino_generator
+
+            return generator.generate(expression, copy=copy)
+
+
+def _tokenize_as_hive(tokens: t.List[Token]) -> bool:
+    if len(tokens) < 2:
+        return False
+
+    first, second, *rest = tokens
+
+    first_type = first.token_type
+    first_text = first.text.upper()
+    second_type = second.token_type
+    second_text = second.text.upper()
+
+    if first_type in (TokenType.DESCRIBE, TokenType.SHOW) or first_text == "MSCK REPAIR":
+        return True
+
+    if first_type in (TokenType.ALTER, TokenType.CREATE, TokenType.DROP):
+        if second_text in ("DATABASE", "EXTERNAL", "SCHEMA"):
+            return True
+        if second_type == TokenType.VIEW:
+            return False
+
+        return all(t.token_type != TokenType.SELECT for t in rest)
+
+    return False
 
 
 def _generate_as_hive(expression: exp.Expression) -> bool:
     if isinstance(expression, exp.Create):
         if expression.kind == "TABLE":
-            properties: t.Optional[exp.Properties] = expression.args.get("properties")
+            properties = expression.args.get("properties")
+
+            # CREATE EXTERNAL TABLE is Hive
             if properties and properties.find(exp.ExternalProperty):
-                return True  # CREATE EXTERNAL TABLE is Hive
+                return True
 
+            # Any CREATE TABLE other than CREATE TABLE ... AS <query> is Hive
             if not isinstance(expression.expression, exp.Query):
-                return True  # any CREATE TABLE other than CREATE TABLE AS SELECT is Hive
+                return True
         else:
-            return expression.kind != "VIEW"  # CREATE VIEW is never Hive but CREATE SCHEMA etc is
-
-    # https://docs.aws.amazon.com/athena/latest/ug/ddl-reference.html
-    elif isinstance(expression, (exp.Alter, exp.Drop, exp.Describe)):
+            # CREATE VIEW is Trino, but CREATE SCHEMA, CREATE DATABASE, etc, is Hive
+            return expression.kind != "VIEW"
+    elif isinstance(expression, (exp.Alter, exp.Drop, exp.Describe, exp.Show)):
         if isinstance(expression, exp.Drop) and expression.kind == "VIEW":
-            # DROP VIEW is Trino (I guess because CREATE VIEW is)
+            # DROP VIEW is Trino, because CREATE VIEW is as well
             return False
 
-        # Everything else is Hive
+        # Everything else, e.g., ALTER statements, is Hive
         return True
 
     return False
 
 
 def _is_iceberg_table(properties: exp.Properties) -> bool:
-    table_type_property = next(
-        (
-            p
-            for p in properties.expressions
-            if isinstance(p, exp.Property) and p.name == "table_type"
-        ),
-        None,
-    )
-    return bool(table_type_property and table_type_property.text("value").lower() == "iceberg")
+    for p in properties.expressions:
+        if isinstance(p, exp.Property) and p.name == "table_type":
+            return p.text("value").lower() == "iceberg"
+
+    return False
 
 
 def _location_property_sql(self: Athena.Generator, e: exp.LocationProperty):
@@ -64,6 +236,7 @@ def _partitioned_by_property_sql(self: Athena.Generator, e: exp.PartitionedByPro
     # ref: https://docs.aws.amazon.com/athena/latest/ug/create-table-as.html#ctas-table-properties
 
     prop_name = "partitioned_by"
+
     if isinstance(e.parent, exp.Properties):
         if _is_iceberg_table(e.parent):
             prop_name = "partitioning"
@@ -71,97 +244,45 @@ def _partitioned_by_property_sql(self: Athena.Generator, e: exp.PartitionedByPro
     return f"{prop_name}={self.sql(e, 'this')}"
 
 
-class Athena(Trino):
-    """
-    Over the years, it looks like AWS has taken various execution engines, bolted on AWS-specific modifications and then
-    built the Athena service around them.
-
-    Thus, Athena is not simply hosted Trino, it's more like a router that routes SQL queries to an execution engine depending
-    on the query type.
-
-    As at 2024-09-10, assuming your Athena workgroup is configured to use "Athena engine version 3", the following engines exist:
-
-    Hive:
-     - Accepts mostly the same syntax as Hadoop / Hive
-     - Uses backticks to quote identifiers
-     - Has a distinctive DDL syntax (around things like setting table properties, storage locations etc) that is different from Trino
-     - Used for *most* DDL, with some exceptions that get routed to the Trino engine instead:
-        - CREATE [EXTERNAL] TABLE (without AS SELECT)
-        - ALTER
-        - DROP
-
-    Trino:
-      - Uses double quotes to quote identifiers
-      - Used for DDL operations that involve SELECT queries, eg:
-        - CREATE VIEW / DROP VIEW
-        - CREATE TABLE... AS SELECT
-      - Used for DML operations
-        - SELECT, INSERT, UPDATE, DELETE, MERGE
-
-    The SQLGlot Athena dialect tries to identify which engine a query would be routed to and then uses the parser / generator for that engine
-    rather than trying to create a universal syntax that can handle both types.
-    """
-
-    class Tokenizer(Trino.Tokenizer):
-        """
-        The Tokenizer is flexible enough to tokenize queries across both the Hive and Trino engines
-        """
-
-        IDENTIFIERS = ['"', "`"]
-        STRING_ESCAPES = ["'", "\\"]
-        KEYWORDS = {
-            **Hive.Tokenizer.KEYWORDS,
-            **Trino.Tokenizer.KEYWORDS,
-            "UNLOAD": TokenType.COMMAND,
-        }
-
-    class Parser(Trino.Parser):
-        """
-        Parse queries for the Athena Trino execution engine
-        """
-
-        STATEMENT_PARSERS = {
-            **Trino.Parser.STATEMENT_PARSERS,
-            TokenType.USING: lambda self: self._parse_as_command(self._prev),
-        }
-
-    class _HiveGenerator(Hive.Generator):
-        def alter_sql(self, expression: exp.Alter) -> str:
-            # package any ALTER TABLE ADD actions into a Schema object
-            # so it gets generated as `ALTER TABLE .. ADD COLUMNS(...)`
-            # instead of `ALTER TABLE ... ADD COLUMN` which is invalid syntax on Athena
-            if isinstance(expression, exp.Alter) and expression.kind == "TABLE":
-                if expression.actions and isinstance(expression.actions[0], exp.ColumnDef):
-                    new_actions = exp.Schema(expressions=expression.actions)
-                    expression.set("actions", [new_actions])
-
-            return super().alter_sql(expression)
-
-    class Generator(Trino.Generator):
-        """
-        Generate queries for the Athena Trino execution engine
-        """
-
-        PROPERTIES_LOCATION = {
-            **Trino.Generator.PROPERTIES_LOCATION,
-            exp.LocationProperty: exp.Properties.Location.POST_WITH,
-        }
-
-        TRANSFORMS = {
-            **Trino.Generator.TRANSFORMS,
-            exp.PartitionedByProperty: _partitioned_by_property_sql,
-            exp.LocationProperty: _location_property_sql,
-        }
-
-        def __init__(self, *args, **kwargs):
-            super().__init__(*args, **kwargs)
-
-            hive_kwargs = {**kwargs, "dialect": "hive"}
-
-            self._hive_generator = Athena._HiveGenerator(*args, **hive_kwargs)
-
-        def generate(self, expression: exp.Expression, copy: bool = True) -> str:
-            if _generate_as_hive(expression):
-                return self._hive_generator.generate(expression, copy)
-
-            return super().generate(expression, copy)
+# Athena extensions to Hive's generator
+class _HiveGenerator(Hive.Generator):
+    def alter_sql(self, expression: exp.Alter) -> str:
+        # Package any ALTER TABLE ADD actions into a Schema object, so it gets generated as
+        # `ALTER TABLE .. ADD COLUMNS(...)`, instead of `ALTER TABLE ... ADD COLUMN`, which
+        # is invalid syntax on Athena
+        if isinstance(expression, exp.Alter) and expression.kind == "TABLE":
+            if expression.actions and isinstance(expression.actions[0], exp.ColumnDef):
+                new_actions = exp.Schema(expressions=expression.actions)
+                expression.set("actions", [new_actions])
+
+        return super().alter_sql(expression)
+
+
+# Athena extensions to Trino's tokenizer
+class _TrinoTokenizer(Trino.Tokenizer):
+    KEYWORDS = {
+        **Trino.Tokenizer.KEYWORDS,
+        "UNLOAD": TokenType.COMMAND,
+    }
+
+
+# Athena extensions to Trino's parser
+class _TrinoParser(Trino.Parser):
+    STATEMENT_PARSERS = {
+        **Trino.Parser.STATEMENT_PARSERS,
+        TokenType.USING: lambda self: self._parse_as_command(self._prev),
+    }
+
+
+# Athena extensions to Trino's generator
+class _TrinoGenerator(Trino.Generator):
+    PROPERTIES_LOCATION = {
+        **Trino.Generator.PROPERTIES_LOCATION,
+        exp.LocationProperty: exp.Properties.Location.POST_WITH,
+    }
+
+    TRANSFORMS = {
+        **Trino.Generator.TRANSFORMS,
+        exp.PartitionedByProperty: _partitioned_by_property_sql,
+        exp.LocationProperty: _location_property_sql,
+    }

sqlglot/dialects/bigquery.py

@@ -30,6 +30,7 @@ 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
@@ -444,6 +445,7 @@ class BigQuery(Dialect):
                 exp.Substring,
             )
         },
+        exp.ArrayConcat: lambda self, e: self._annotate_by_args(e, "this", "expressions"),
         exp.Concat: _annotate_concat,
         exp.Sign: lambda self, e: self._annotate_by_args(e, "this"),
         exp.Split: lambda self, e: self._annotate_by_args(e, "this", array=True),
@@ -1011,6 +1013,7 @@ 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/clickhouse.py

@@ -303,6 +303,8 @@ class ClickHouse(Dialect):
             **parser.Parser.FUNCTIONS,
             "ANY": exp.AnyValue.from_arg_list,
             "ARRAYSUM": exp.ArraySum.from_arg_list,
+            "ARRAYREVERSE": exp.ArrayReverse.from_arg_list,
+            "ARRAYSLICE": exp.ArraySlice.from_arg_list,
             "COUNTIF": _build_count_if,
             "DATE_ADD": build_date_delta(exp.DateAdd, default_unit=None),
             "DATEADD": build_date_delta(exp.DateAdd, default_unit=None),
@@ -330,6 +332,7 @@ class ClickHouse(Dialect):
             "MD5": exp.MD5Digest.from_arg_list,
             "SHA256": lambda args: exp.SHA2(this=seq_get(args, 0), length=exp.Literal.number(256)),
             "SHA512": lambda args: exp.SHA2(this=seq_get(args, 0), length=exp.Literal.number(512)),
+            "SUBSTRINGINDEX": exp.SubstringIndex.from_arg_list,  # alias for camel-case substringIndex
             "EDITDISTANCE": exp.Levenshtein.from_arg_list,
             "LEVENSHTEINDISTANCE": exp.Levenshtein.from_arg_list,
         }
@@ -1065,6 +1068,8 @@ class ClickHouse(Dialect):
             exp.ArrayConcat: rename_func("arrayConcat"),
             exp.ArrayFilter: lambda self, e: self.func("arrayFilter", e.expression, e.this),
             exp.ArrayRemove: remove_from_array_using_filter,
+            exp.ArrayReverse: rename_func("arrayReverse"),
+            exp.ArraySlice: rename_func("arraySlice"),
             exp.ArraySum: rename_func("arraySum"),
             exp.ArgMax: arg_max_or_min_no_count("argMax"),
             exp.ArgMin: arg_max_or_min_no_count("argMin"),

sqlglot/dialects/dialect.py

@@ -73,6 +73,7 @@ class Dialects(str, Enum):
     CLICKHOUSE = "clickhouse"
     DATABRICKS = "databricks"
     DORIS = "doris"
+    DREMIO = "dremio"
     DRILL = "drill"
     DRUID = "druid"
     DUCKDB = "duckdb"
@@ -759,6 +760,12 @@ class Dialect(metaclass=_Dialect):
         exp.Array: lambda self, e: self._annotate_by_args(e, "expressions", array=True),
         exp.ArrayAgg: lambda self, e: self._annotate_by_args(e, "this", array=True),
         exp.ArrayConcat: lambda self, e: self._annotate_by_args(e, "this", "expressions"),
+        exp.ArrayConcatAgg: lambda self, e: self._annotate_by_args(e, "this"),
+        exp.ArrayToString: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.TEXT),
+        exp.ArrayFirst: lambda self, e: self._annotate_by_array_element(e),
+        exp.ArrayLast: lambda self, e: self._annotate_by_array_element(e),
+        exp.ArrayReverse: lambda self, e: self._annotate_by_args(e, "this"),
+        exp.ArraySlice: lambda self, e: self._annotate_by_args(e, "this"),
         exp.Bracket: lambda self, e: self._annotate_bracket(e),
         exp.Cast: lambda self, e: self._annotate_with_type(e, e.args["to"]),
         exp.Case: lambda self, e: self._annotate_by_args(e, "default", "ifs"),
@@ -1028,22 +1035,20 @@ class Dialect(metaclass=_Dialect):
             for expression in self.parse(sql)
         ]
 
-    def tokenize(self, sql: str) -> t.List[Token]:
-        return self.tokenizer.tokenize(sql)
+    def tokenize(self, sql: str, **opts) -> t.List[Token]:
+        return self.tokenizer(**opts).tokenize(sql)
 
-    @property
-    def tokenizer(self) -> Tokenizer:
-        return self.tokenizer_class(dialect=self)
+    def tokenizer(self, **opts) -> Tokenizer:
+        return self.tokenizer_class(**{"dialect": self, **opts})
 
-    @property
-    def jsonpath_tokenizer(self) -> JSONPathTokenizer:
-        return self.jsonpath_tokenizer_class(dialect=self)
+    def jsonpath_tokenizer(self, **opts) -> JSONPathTokenizer:
+        return self.jsonpath_tokenizer_class(**{"dialect": self, **opts})
 
     def parser(self, **opts) -> Parser:
-        return self.parser_class(dialect=self, **opts)
+        return self.parser_class(**{"dialect": self, **opts})
 
     def generator(self, **opts) -> Generator:
-        return self.generator_class(dialect=self, **opts)
+        return self.generator_class(**{"dialect": self, **opts})
 
     def generate_values_aliases(self, expression: exp.Values) -> t.List[exp.Identifier]:
         return [
@@ -1930,3 +1935,12 @@ 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

@@ -0,0 +1,53 @@
+from sqlglot import expressions as exp
+from sqlglot import parser, generator, tokens
+from sqlglot.dialects.dialect import Dialect
+
+
+class Dremio(Dialect):
+    SUPPORTS_USER_DEFINED_TYPES = False
+    CONCAT_COALESCE = True
+    TYPED_DIVISION = True
+    SUPPORTS_SEMI_ANTI_JOIN = False
+    NULL_ORDERING = "nulls_are_last"
+    SUPPORTS_VALUES_DEFAULT = False
+
+    class Parser(parser.Parser):
+        LOG_DEFAULTS_TO_LN = True
+
+    class Generator(generator.Generator):
+        NVL2_SUPPORTED = False
+        SUPPORTS_CONVERT_TIMEZONE = True
+        INTERVAL_ALLOWS_PLURAL_FORM = False
+        JOIN_HINTS = False
+        LIMIT_ONLY_LITERALS = True
+        MULTI_ARG_DISTINCT = False
+
+        # https://docs.dremio.com/current/reference/sql/data-types/
+        TYPE_MAPPING = {
+            **generator.Generator.TYPE_MAPPING,
+            exp.DataType.Type.SMALLINT: "INT",
+            exp.DataType.Type.TINYINT: "INT",
+            exp.DataType.Type.BINARY: "VARBINARY",
+            exp.DataType.Type.TEXT: "VARCHAR",
+            exp.DataType.Type.NCHAR: "VARCHAR",
+            exp.DataType.Type.CHAR: "VARCHAR",
+            exp.DataType.Type.TIMESTAMPNTZ: "TIMESTAMP",
+            exp.DataType.Type.DATETIME: "TIMESTAMP",
+            exp.DataType.Type.ARRAY: "LIST",
+            exp.DataType.Type.BIT: "BOOLEAN",
+        }
+
+        def datatype_sql(self, expression: exp.DataType) -> str:
+            """
+            Reject time-zone–aware TIMESTAMPs, which Dremio does not accept
+            """
+            if expression.is_type(
+                exp.DataType.Type.TIMESTAMPTZ,
+                exp.DataType.Type.TIMESTAMPLTZ,
+            ):
+                self.unsupported("Dremio does not support time-zone-aware TIMESTAMP")
+
+            return super().datatype_sql(expression)
+
+    class Tokenizer(tokens.Tokenizer):
+        COMMENTS = ["--", "//", ("/*", "*/")]

sqlglot/dialects/duckdb.py

@@ -1165,3 +1165,48 @@ class DuckDB(Dialect):
         def autoincrementcolumnconstraint_sql(self, _) -> str:
             self.unsupported("The AUTOINCREMENT column constraint is not supported by DuckDB")
             return ""
+
+        def aliases_sql(self, expression: exp.Aliases) -> str:
+            this = expression.this
+            if isinstance(this, exp.Posexplode):
+                return self.posexplode_sql(this)
+
+            return super().aliases_sql(expression)
+
+        def posexplode_sql(self, expression: exp.Posexplode) -> str:
+            this = expression.this
+            parent = expression.parent
+
+            # The default Spark aliases are "pos" and "col", unless specified otherwise
+            pos, col = exp.to_identifier("pos"), exp.to_identifier("col")
+
+            if isinstance(parent, exp.Aliases):
+                # Column case: SELECT POSEXPLODE(col) [AS (a, b)]
+                pos, col = parent.expressions
+            elif isinstance(parent, exp.Table):
+                # Table case: SELECT * FROM POSEXPLODE(col) [AS (a, b)]
+                alias = parent.args.get("alias")
+                if alias:
+                    pos, col = alias.columns or [pos, col]
+                    alias.pop()
+
+            # Translate POSEXPLODE to UNNEST + GENERATE_SUBSCRIPTS
+            # Note: In Spark pos is 0-indexed, but in DuckDB it's 1-indexed, so we subtract 1 from GENERATE_SUBSCRIPTS
+            unnest_sql = self.sql(exp.Unnest(expressions=[this], alias=col))
+            gen_subscripts = self.sql(
+                exp.Alias(
+                    this=exp.Anonymous(
+                        this="GENERATE_SUBSCRIPTS", expressions=[this, exp.Literal.number(1)]
+                    )
+                    - exp.Literal.number(1),
+                    alias=pos,
+                )
+            )
+
+            posexplode_sql = self.format_args(gen_subscripts, unnest_sql)
+
+            if isinstance(parent, exp.From) or (parent and isinstance(parent.parent, exp.From)):
+                # SELECT * FROM POSEXPLODE(col) -> SELECT * FROM (SELECT GENERATE_SUBSCRIPTS(...), UNNEST(...))
+                return self.sql(exp.Subquery(this=exp.Select(expressions=[posexplode_sql])))
+
+            return posexplode_sql

sqlglot/dialects/exasol.py

@@ -1,9 +1,31 @@
 from __future__ import annotations
-from sqlglot import exp, generator
-from sqlglot.dialects.dialect import Dialect, rename_func
+from sqlglot import exp, generator, parser
+from sqlglot.dialects.dialect import Dialect, rename_func, binary_from_function
+from sqlglot.helper import seq_get
+from sqlglot.generator import unsupported_args
 
 
 class Exasol(Dialect):
+    class Parser(parser.Parser):
+        FUNCTIONS = {
+            **parser.Parser.FUNCTIONS,
+            "BIT_AND": binary_from_function(exp.BitwiseAnd),
+            "BIT_OR": binary_from_function(exp.BitwiseOr),
+            "BIT_XOR": binary_from_function(exp.BitwiseXor),
+            "BIT_NOT": lambda args: exp.BitwiseNot(this=seq_get(args, 0)),
+            "BIT_LSHIFT": binary_from_function(exp.BitwiseLeftShift),
+            "BIT_RSHIFT": binary_from_function(exp.BitwiseRightShift),
+            "EVERY": lambda args: exp.All(this=seq_get(args, 0)),
+            "EDIT_DISTANCE": exp.Levenshtein.from_arg_list,
+            "REGEXP_REPLACE": lambda args: exp.RegexpReplace(
+                this=seq_get(args, 0),
+                expression=seq_get(args, 1),
+                replacement=seq_get(args, 2),
+                position=seq_get(args, 3),
+                occurrence=seq_get(args, 4),
+            ),
+        }
+
     class Generator(generator.Generator):
         # https://docs.exasol.com/db/latest/sql_references/data_types/datatypedetails.htm#StringDataType
         STRING_TYPE_MAPPING = {
@@ -41,6 +63,27 @@ class Exasol(Dialect):
 
         TRANSFORMS = {
             **generator.Generator.TRANSFORMS,
+            # https://docs.exasol.com/db/latest/sql_references/functions/alphabeticallistfunctions/every.htm
+            exp.All: rename_func("EVERY"),
+            # https://docs.exasol.com/db/latest/sql_references/functions/alphabeticallistfunctions/bit_and.htm
+            exp.BitwiseAnd: rename_func("BIT_AND"),
+            # https://docs.exasol.com/db/latest/sql_references/functions/alphabeticallistfunctions/bit_or.htm
+            exp.BitwiseOr: rename_func("BIT_OR"),
+            # https://docs.exasol.com/db/latest/sql_references/functions/alphabeticallistfunctions/bit_not.htm
+            exp.BitwiseNot: rename_func("BIT_NOT"),
+            # https://docs.exasol.com/db/latest/sql_references/functions/alphabeticallistfunctions/bit_lshift.htm
+            exp.BitwiseLeftShift: rename_func("BIT_LSHIFT"),
+            # https://docs.exasol.com/db/latest/sql_references/functions/alphabeticallistfunctions/bit_rshift.htm
+            exp.BitwiseRightShift: rename_func("BIT_RSHIFT"),
+            # https://docs.exasol.com/db/latest/sql_references/functions/alphabeticallistfunctions/bit_xor.htm
+            exp.BitwiseXor: rename_func("BIT_XOR"),
+            # https://docs.exasol.com/db/latest/sql_references/functions/alphabeticallistfunctions/every.htm
+            exp.All: rename_func("EVERY"),
+            # 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")
+            ),
             # https://docs.exasol.com/db/latest/sql_references/functions/alphabeticallistfunctions/mod.htm
             exp.Mod: rename_func("MOD"),
+            exp.RegexpReplace: unsupported_args("modifiers")(rename_func("REGEXP_REPLACE")),
         }

sqlglot/dialects/presto.py

@@ -31,6 +31,7 @@ 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
@@ -369,6 +370,7 @@ class Presto(Dialect):
             "STRPOS": lambda args: exp.StrPosition(
                 this=seq_get(args, 0), substr=seq_get(args, 1), occurrence=seq_get(args, 2)
             ),
+            "SLICE": exp.ArraySlice.from_arg_list,
             "TO_CHAR": _build_to_char,
             "TO_UNIXTIME": exp.TimeToUnix.from_arg_list,
             "TO_UTF8": lambda args: exp.Encode(
@@ -437,6 +439,7 @@ class Presto(Dialect):
             exp.ArrayContains: rename_func("CONTAINS"),
             exp.ArrayToString: rename_func("ARRAY_JOIN"),
             exp.ArrayUniqueAgg: rename_func("SET_AGG"),
+            exp.ArraySlice: rename_func("SLICE"),
             exp.AtTimeZone: rename_func("AT_TIMEZONE"),
             exp.BitwiseAnd: lambda self, e: self.func("BITWISE_AND", e.this, e.expression),
             exp.BitwiseLeftShift: lambda self, e: self.func(
@@ -503,6 +506,7 @@ 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/spark2.py

@@ -201,6 +201,7 @@ class Spark2(Hive):
             "SHIFTLEFT": binary_from_function(exp.BitwiseLeftShift),
             "SHIFTRIGHT": binary_from_function(exp.BitwiseRightShift),
             "STRING": _build_as_cast("string"),
+            "SLICE": exp.ArraySlice.from_arg_list,
             "TIMESTAMP": _build_as_cast("timestamp"),
             "TO_TIMESTAMP": lambda args: (
                 _build_as_cast("timestamp")(args)
@@ -261,6 +262,7 @@ class Spark2(Hive):
             exp.ArraySum: lambda self,
             e: f"AGGREGATE({self.sql(e, 'this')}, 0, (acc, x) -> acc + x, acc -> acc)",
             exp.ArrayToString: rename_func("ARRAY_JOIN"),
+            exp.ArraySlice: rename_func("SLICE"),
             exp.AtTimeZone: lambda self, e: self.func(
                 "FROM_UTC_TIMESTAMP", e.this, e.args.get("zone")
             ),

sqlglot/expressions.py

@@ -5569,6 +5569,22 @@ class ArrayFilter(Func):
     _sql_names = ["FILTER", "ARRAY_FILTER"]
 
 
+class ArrayFirst(Func):
+    pass
+
+
+class ArrayLast(Func):
+    pass
+
+
+class ArrayReverse(Func):
+    pass
+
+
+class ArraySlice(Func):
+    arg_types = {"this": True, "start": True, "end": False, "step": False}
+
+
 class ArrayToString(Func):
     arg_types = {"this": True, "expression": True, "null": False}
     _sql_names = ["ARRAY_TO_STRING", "ARRAY_JOIN"]
@@ -6723,6 +6739,17 @@ class Substring(Func):
     arg_types = {"this": True, "start": False, "length": False}
 
 
+class SubstringIndex(Func):
+    """
+    SUBSTRING_INDEX(str, delim, count)
+
+    *count* > 0  → left slice before the *count*-th delimiter
+    *count* < 0  → right slice after the |count|-th delimiter
+    """
+
+    arg_types = {"this": True, "delimiter": True, "count": True}
+
+
 class StandardHash(Func):
     arg_types = {"this": True, "expression": False}
 
@@ -6779,6 +6806,14 @@ class FromBase(Func):
     arg_types = {"this": True, "expression": True}
 
 
+class Space(Func):
+    """
+    SPACE(n) → string consisting of n blank characters
+    """
+
+    pass
+
+
 class Struct(Func):
     arg_types = {"expressions": False}
     is_var_len_args = True

sqlglot/jsonpath.py

@@ -41,7 +41,7 @@ def parse(path: str, dialect: DialectType = None) -> exp.JSONPath:
     """Takes in a JSON path string and parses it into a JSONPath expression."""
     from sqlglot.dialects import Dialect
 
-    jsonpath_tokenizer = Dialect.get_or_raise(dialect).jsonpath_tokenizer
+    jsonpath_tokenizer = Dialect.get_or_raise(dialect).jsonpath_tokenizer()
     tokens = jsonpath_tokenizer.tokenize(path)
     size = len(tokens)
 

sqlglot/optimizer/annotate_types.py

@@ -329,6 +329,7 @@ class TypeAnnotator(metaclass=_TypeAnnotator):
                 ],
                 nested=True,
             )
+
             if not any(
                 cd.kind.is_type(exp.DataType.Type.UNKNOWN)
                 for cd in struct_type.expressions
@@ -630,3 +631,15 @@ class TypeAnnotator(metaclass=_TypeAnnotator):
         else:
             self._set_type(expression, exp.DataType.Type.INT)
         return expression
+
+    def _annotate_by_array_element(self, expression: exp.Expression) -> exp.Expression:
+        self._annotate_args(expression)
+
+        array_arg = expression.this
+        if array_arg.type.is_type(exp.DataType.Type.ARRAY):
+            element_type = seq_get(array_arg.type.expressions, 0) or exp.DataType.Type.UNKNOWN
+            self._set_type(expression, element_type)
+        else:
+            self._set_type(expression, exp.DataType.Type.UNKNOWN)
+
+        return expression

sqlglot/optimizer/pushdown_predicates.py

@@ -21,12 +21,13 @@ def pushdown_predicates(expression, dialect=None):
     Returns:
         sqlglot.Expression: optimized expression
     """
+    from sqlglot.dialects.athena import Athena
     from sqlglot.dialects.presto import Presto
 
     root = build_scope(expression)
 
     dialect = Dialect.get_or_raise(dialect)
-    unnest_requires_cross_join = isinstance(dialect, Presto)
+    unnest_requires_cross_join = isinstance(dialect, (Athena, Presto))
 
     if root:
         scope_ref_count = root.ref_count()

sqlglot/parser.py

@@ -1895,7 +1895,7 @@ class Parser(metaclass=_Parser):
             stmt.add_comments(comments, prepend=True)
             return stmt
 
-        if self._match_set(self.dialect.tokenizer.COMMANDS):
+        if self._match_set(self.dialect.tokenizer_class.COMMANDS):
             return self._parse_command()
 
         expression = self._parse_expression()

sqlglot/tokens.py

@@ -427,6 +427,9 @@ class TokenType(AutoName):
     NAMESPACE = auto()
     EXPORT = auto()
 
+    # sentinel
+    HIVE_TOKEN_STREAM = auto()
+
 
 _ALL_TOKEN_TYPES = list(TokenType)
 _TOKEN_TYPE_TO_INDEX = {token_type: i for i, token_type in enumerate(_ALL_TOKEN_TYPES)}
@@ -1014,7 +1017,10 @@ class Tokenizer(metaclass=_Tokenizer):
     )
 
     def __init__(
-        self, dialect: DialectType = None, use_rs_tokenizer: t.Optional[bool] = None
+        self,
+        dialect: DialectType = None,
+        use_rs_tokenizer: t.Optional[bool] = None,
+        **opts: t.Any,
     ) -> None:
         from sqlglot.dialects import Dialect
 

{sqlglot-26.31.0.dist-info → sqlglot-26.32.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlglot
-Version: 26.31.0
+Version: 26.32.0
 Summary: An easily customizable SQL parser and transpiler
 Author-email: Toby Mao <toby.mao@gmail.com>
 License: MIT License

{sqlglot-26.31.0.dist-info → sqlglot-26.32.0.dist-info}/RECORD

@@ -1,48 +1,49 @@
 sqlglot/__init__.py,sha256=za08rtdPh2v7dOpGdNomttlIVGgTrKja7rPd6sQwaTg,5391
 sqlglot/__main__.py,sha256=022c173KqxsiABWTEpUIq_tJUxuNiW7a7ABsxBXqvu8,2069
 sqlglot/_typing.py,sha256=-1HPyr3w5COlSJWqlgt8jhFk2dyMvBuvVBqIX1wyVCM,642
-sqlglot/_version.py,sha256=X5X34o5ymsD4ydxIloUOjJGcZ-0Zi6rgP-736DtnUZ8,515
+sqlglot/_version.py,sha256=a_It9JwWrgyjKVWp4-1klpG0OQem5zJtgb83vsDFdkQ,515
 sqlglot/diff.py,sha256=PtOllQMQa1Sw1-V2Y8eypmDqGujXYPaTOp_WLsWkAWk,17314
 sqlglot/errors.py,sha256=QNKMr-pzLUDR-tuMmn_GK6iMHUIVdb_YSJ_BhGEvuso,2126
-sqlglot/expressions.py,sha256=rYPkorYfWlBzPxyaodGqIkW-x6RG1gSkVjBkOfkdZiI,243434
+sqlglot/expressions.py,sha256=4ucsMtJKzFpFm_SLb5YylQGsAjIbrwYprwk2QEKUKK4,244025
 sqlglot/generator.py,sha256=Od0aBsKJph1wG_YhrknJAcAcVvuVIN823iyxA3KPi0Y,213383
 sqlglot/helper.py,sha256=9nZjFVRBtMKFC3EdzpDQ6jkazFO19po6BF8xHiNGZIo,15111
-sqlglot/jsonpath.py,sha256=dKdI3PNINNGimmSse2IIv-GbPN_3lXncXh_70QH7Lss,7664
+sqlglot/jsonpath.py,sha256=jneO-A57n4ojVT2drCn2HBlx_Ka8wLcGpemW1JgvbjA,7666
 sqlglot/lineage.py,sha256=kXBDSErmZZluZx_kkrMj4MPEOAbkvcbX1tbOW7Bpl-U,15303
-sqlglot/parser.py,sha256=Mqm77jhuF0b3hyuFPgYtLAMPkuslF64Y8iHIOPw3ZWA,324610
+sqlglot/parser.py,sha256=uoqObZn91ixqajoTUvHYiZXylaMbsuL2c4bdSyOCSFU,324616
 sqlglot/planner.py,sha256=ql7Li-bWJRcyXzNaZy_n6bQ6B2ZfunEIB8Ztv2xaxq4,14634
 sqlglot/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sqlglot/schema.py,sha256=13H2qKQs27EKdTpDLOvcNnSTDAUbYNKjWtJs4aQCSOA,20509
 sqlglot/serde.py,sha256=DQVJ95WrIvhYfe02Ytb4NQug2aMwDCEwpMBW1LKDqzE,2031
 sqlglot/time.py,sha256=Q62gv6kL40OiRBF6BMESxKJcMVn7ZLNw7sv8H34z5FI,18400
-sqlglot/tokens.py,sha256=R0B8GQSbQ9GoDc0NlaT5Tc8RjgEOx2IYIkYU5rY8Rg8,48742
+sqlglot/tokens.py,sha256=QciEA4QXiUmoVLWbd67Uf90BQvGaAvnYiZm9plqIpC8,48829
 sqlglot/transforms.py,sha256=s96QMtR7rJbcLAU1I_IF1xLNxno6yvEbhERgbS5xmJ4,41164
 sqlglot/trie.py,sha256=v27uXMrHfqrXlJ6GmeTSMovsB_3o0ctnlKhdNt7W6fI,2245
-sqlglot/dialects/__init__.py,sha256=G-YO1_zIcONWb9LjTjHX_HGzGl9Rm0sA9MX4ok6tpns,3527
-sqlglot/dialects/athena.py,sha256=gPE9ybRcbd6dVa1mrTFB_eVjsjQG36hErq5EpHyQmXo,6344
-sqlglot/dialects/bigquery.py,sha256=5s4hSe-PXbjeIlKhAZon-rGq4ZIywYZj1kxx213V748,52862
-sqlglot/dialects/clickhouse.py,sha256=Dc0aXwEgN8b6coXKM6P8zh3IsyrXjBajNGB-cVhnu1Y,56603
+sqlglot/dialects/__init__.py,sha256=uxgw-b-QoqVFGbj1zW0p61f1mhV9oF0qscuBB0e7bkI,3541
+sqlglot/dialects/athena.py,sha256=ofArmayYLev4qZQ15GM8mevG04qqR5WGFb2ZcuYm6x4,10966
+sqlglot/dialects/bigquery.py,sha256=0HyMete6v-x1Thp9FVCppVjQoAcgenqg7Zl7wGPh3dA,53002
+sqlglot/dialects/clickhouse.py,sha256=U_s6fRQbj3eFEaNw7N7UWC8EzYnFVYI-KKIsk-IU1I4,56936
 sqlglot/dialects/databricks.py,sha256=mJN2lFpqgH95x3mtry3qWbuRf4q7NV5jbRAOspqclzY,4548
-sqlglot/dialects/dialect.py,sha256=qcpaE4cYO3v2R1cQVonpbrJOybYspnEdXSkXWxDW6d4,68921
+sqlglot/dialects/dialect.py,sha256=ef933149Zk4tvoNmEAu7W6bteRbMkxnoBValfIVDOso,69667
 sqlglot/dialects/doris.py,sha256=eC7Ct-iz7p4Usz659NkelUFhm-GmVolIZy5uaBvgjaA,14397
+sqlglot/dialects/dremio.py,sha256=qTKZnVBGw6Tfco9MmsfIhKKYqJ4_TXaEhDCbEKNU9Uw,1866
 sqlglot/dialects/drill.py,sha256=FOh7_KjPx_77pv0DiHKZog0CcmzqeF9_PEmGnJ1ESSM,5825
 sqlglot/dialects/druid.py,sha256=kh3snZtneehNOWqs3XcPjsrhNaRbkCQ8E4hHbWJ1fHM,690
-sqlglot/dialects/duckdb.py,sha256=oGCgK0KjwJcCKy-YOZeiQnEo4v7Zc1r5AK0tCXO2VIc,48005
+sqlglot/dialects/duckdb.py,sha256=L1pNYEQjiH2dYJurMXXYihgRalN9gZhmd5LoqCr_wvg,50015
 sqlglot/dialects/dune.py,sha256=gALut-fFfN2qMsr8LvZ1NQK3F3W9z2f4PwMvTMXVVVg,375
-sqlglot/dialects/exasol.py,sha256=r2fO9FHfMV1_1M62wBGlNcQ6fHWikO4SBr8eCzxEYEY,2008
+sqlglot/dialects/exasol.py,sha256=SbLg6l_BgI_hyZvLnnMh6m3WnBSqB3ZavLbLqE_vfjI,4726
 sqlglot/dialects/fabric.py,sha256=IU7aMh2yEuG8eVBAYzXO5pObZBZ4rZSd5UgvkwbCI-E,5277
 sqlglot/dialects/hive.py,sha256=yKCsVN4R8pIB2Lmx1YGiSR9b8Me3li6rsGuZrKjHTo4,31771
 sqlglot/dialects/materialize.py,sha256=_DPLPt8YrdQIIXNrGJw1IMcGOoAEJ9NO9X9pDfy4hxs,3494
 sqlglot/dialects/mysql.py,sha256=prZecn3zeoifZX7l54UuLG64ar7I-or_z9lF-rT8bds,49233
 sqlglot/dialects/oracle.py,sha256=o6On1cYWFt6TpQYKuzo4kCz5vKb8jQr8WSwc619h3Lg,15967
 sqlglot/dialects/postgres.py,sha256=KUyMoLkm1_sZKUbdjn6bjXx9xz7sbEMKa-fl5Mzfrsk,31025
-sqlglot/dialects/presto.py,sha256=dHdPv6tUO-7SAYUWnx5ftKzv6FcRvzBfiYDTlQvL2Cs,33312
+sqlglot/dialects/presto.py,sha256=Tm3Bx9AJilT1xlgunTpF0wUhIZBOPS-rB5Iwitnygxc,33462
 sqlglot/dialects/prql.py,sha256=fwN-SPEGx-drwf1K0U2MByN-PkW3C_rOgQ3xeJeychg,7908
 sqlglot/dialects/redshift.py,sha256=sHhibn2g6_hVRd1XEe8HSQd_ofWkEpzld0odsNQ6X2g,15747
 sqlglot/dialects/risingwave.py,sha256=hwEOPjMw0ZM_3fjQcBUE00oy6I8V6mzYOOYmcwwS8mw,2898
 sqlglot/dialects/snowflake.py,sha256=68I7OjdWXSVnDxJ-ItmXnJd-A1nlND1T6aKNv0nkJlQ,63518
 sqlglot/dialects/spark.py,sha256=bOUSXUoWtLfWaQ9fIjWaw4zLBJY6N7vxajdMbAxLdOk,8307
-sqlglot/dialects/spark2.py,sha256=8er7nHDm5Wc57m9AOxKN0sd_DVzbhAL44H_udlFh9O8,14258
+sqlglot/dialects/spark2.py,sha256=EsuPGf0WQQzLy16D_uzVF0zKPyiiyxqfEQmsTegZ_IQ,14359
 sqlglot/dialects/sqlite.py,sha256=fwqmopeuoupD_2dh2q6rT3UFxWtFHkskZ1OXAYnPT9Q,12483
 sqlglot/dialects/starrocks.py,sha256=fHNgvq5Nz7dI4QUWCTOO5VDOYjasBxRRlcg9TbY0UZE,11235
 sqlglot/dialects/tableau.py,sha256=oIawDzUITxGCWaEMB8OaNMPWhbC3U-2y09pYPm4eazc,2190
@@ -55,7 +56,7 @@ sqlglot/executor/env.py,sha256=tQhU5PpTBMcxgZIFddFqxWMNPtHN0vOOz72voncY3KY,8276
 sqlglot/executor/python.py,sha256=09GYRzrPn3lZGfDJY9pbONOvmYxsRyeSWjUiqkSRHGo,16661
 sqlglot/executor/table.py,sha256=xkuJlgLVNYUXsSUaX0zTcnFekldXLLU8LqDyjR5K9wY,4419
 sqlglot/optimizer/__init__.py,sha256=FdAvVz6rQLLkiiH21-SD4RxB5zS3WDeU-s03PZkJ-F4,343
-sqlglot/optimizer/annotate_types.py,sha256=-JkNgc5R1jYh130D8lGv5nYSmPddv4Naf3BZiD5ZuTs,24137
+sqlglot/optimizer/annotate_types.py,sha256=Ndfdvc0OO07DCCFuryK1tHkX9ydS-dMxKPgaZU0knWY,24619
 sqlglot/optimizer/canonicalize.py,sha256=RJpUbWDudjknRMtO_Kf8MGZ5Hv1twpPWac2u5kpV4Vw,7719
 sqlglot/optimizer/eliminate_ctes.py,sha256=fUBM0RUnPrm2sYptEWBux98B7fcx7W-BM1zVqfgDz9c,1448
 sqlglot/optimizer/eliminate_joins.py,sha256=5Whliegc7U8BnS6tlrl9wkeAgyP1NpgCCAPxChHzFfw,5874
@@ -66,7 +67,7 @@ sqlglot/optimizer/normalize.py,sha256=wu3GeKY36PLyAb9f534jDDfzDwvZJpZ8g_H5QH6acZ
 sqlglot/optimizer/normalize_identifiers.py,sha256=uD4xICJAgj0X7EFc2LYcDWxAW2aTHANO2wy7kfn9gfY,2098
 sqlglot/optimizer/optimize_joins.py,sha256=LLBH6Zk0Uegsff48soJgJqhpGXkQx5VstGEt40vsjrg,2991
 sqlglot/optimizer/optimizer.py,sha256=vXEXDWHvbO-vJmSI7UqJuydM2WrD1xko7rETq2EtVJo,3533
-sqlglot/optimizer/pushdown_predicates.py,sha256=H4lFc9Dsds8W7FOsE4wbK6PHJBu6SjgQU7mVtl4laps,8357
+sqlglot/optimizer/pushdown_predicates.py,sha256=HGjs3Z4V3-X2d1VTfWhyByY3aL5SmKnVvt3aDXiiBM0,8414
 sqlglot/optimizer/pushdown_projections.py,sha256=7NoK5NAUVYVhs0YnYyo6WuXfaO-BShSwS6lA8Y-ATQ4,6668
 sqlglot/optimizer/qualify.py,sha256=oAPfwub7dEkrlCrsptcJWpLya4BgKhN6M5SwIs_86LY,4002
 sqlglot/optimizer/qualify_columns.py,sha256=77aScPakXYaiagnoCWk2qwMxlKuRGsFTAK9sOQuR2vY,40872
@@ -74,8 +75,8 @@ sqlglot/optimizer/qualify_tables.py,sha256=5f5enBAh-bpNB9ewF97W9fx9h1TGXj1Ih5fnc
 sqlglot/optimizer/scope.py,sha256=HI3TZ4VWTgM6_x8k5ClA0lA0xidaKv4xgn8iGERJRjk,30824
 sqlglot/optimizer/simplify.py,sha256=S0Blqg5Mq2KRRWhWz-Eivch9sBjBhg9fRJA6EdBzj2g,50704
 sqlglot/optimizer/unnest_subqueries.py,sha256=kzWUVDlxs8z9nmRx-8U-pHXPtVZhEIwkKqmKhr2QLvc,10908
-sqlglot-26.31.0.dist-info/licenses/LICENSE,sha256=AI3__mHZfOtzY3EluR_pIYBm3_pE7TbVx7qaHxoZ114,1065
-sqlglot-26.31.0.dist-info/METADATA,sha256=OAEEcPh5a0gV2C4sacAbhuXg4cpNWPUXeGS0H6iAGgs,20732
-sqlglot-26.31.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sqlglot-26.31.0.dist-info/top_level.txt,sha256=5kRskCGA_gVADF9rSfSzPdLHXqvfMusDYeHePfNY2nQ,8
-sqlglot-26.31.0.dist-info/RECORD,,
+sqlglot-26.32.0.dist-info/licenses/LICENSE,sha256=AI3__mHZfOtzY3EluR_pIYBm3_pE7TbVx7qaHxoZ114,1065
+sqlglot-26.32.0.dist-info/METADATA,sha256=SeIGypJ6sJWF3j-g1zmBeptAwZOPUn61UyUJyp7qF5k,20732
+sqlglot-26.32.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sqlglot-26.32.0.dist-info/top_level.txt,sha256=5kRskCGA_gVADF9rSfSzPdLHXqvfMusDYeHePfNY2nQ,8
+sqlglot-26.32.0.dist-info/RECORD,,