sqlglot 26.29.0__py3-none-any.whl → 26.31.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.29.0'
-__version_tuple__ = version_tuple = (26, 29, 0)
+__version__ = version = '26.31.0'
+__version_tuple__ = version_tuple = (26, 31, 0)

sqlglot/dialects/__init__.py

@@ -74,6 +74,7 @@ DIALECTS = [
     "Druid",
     "DuckDB",
     "Dune",
+    "Fabric",
     "Hive",
     "Materialize",
     "MySQL",
@@ -92,6 +93,7 @@ DIALECTS = [
     "Teradata",
     "Trino",
     "TSQL",
+    "Exasol",
 ]
 
 MODULE_BY_DIALECT = {name: name.lower() for name in DIALECTS}

sqlglot/dialects/bigquery.py

@@ -524,6 +524,7 @@ class BigQuery(Dialect):
         PREFIXED_PIVOT_COLUMNS = True
         LOG_DEFAULTS_TO_LN = True
         SUPPORTS_IMPLICIT_UNNEST = True
+        JOINS_HAVE_EQUAL_PRECEDENCE = True
 
         # BigQuery does not allow ASC/DESC to be used as an identifier
         ID_VAR_TOKENS = parser.Parser.ID_VAR_TOKENS - {TokenType.ASC, TokenType.DESC}
@@ -542,7 +543,7 @@ class BigQuery(Dialect):
             "DATE_ADD": build_date_delta_with_interval(exp.DateAdd),
             "DATE_SUB": build_date_delta_with_interval(exp.DateSub),
             "DATE_TRUNC": lambda args: exp.DateTrunc(
-                unit=exp.Literal.string(str(seq_get(args, 1))),
+                unit=seq_get(args, 1),
                 this=seq_get(args, 0),
                 zone=seq_get(args, 2),
             ),
@@ -962,9 +963,6 @@ class BigQuery(Dialect):
             exp.DateSub: date_add_interval_sql("DATE", "SUB"),
             exp.DatetimeAdd: date_add_interval_sql("DATETIME", "ADD"),
             exp.DatetimeSub: date_add_interval_sql("DATETIME", "SUB"),
-            exp.DateTrunc: lambda self, e: self.func(
-                "DATE_TRUNC", e.this, e.text("unit"), e.args.get("zone")
-            ),
             exp.FromTimeZone: lambda self, e: self.func(
                 "DATETIME", self.func("TIMESTAMP", e.this, e.args.get("zone")), "'UTC'"
             ),
@@ -1194,6 +1192,11 @@ class BigQuery(Dialect):
             "within",
         }
 
+        def datetrunc_sql(self, expression: exp.DateTrunc) -> str:
+            unit = expression.unit
+            unit_sql = unit.name if unit.is_string else self.sql(unit)
+            return self.func("DATE_TRUNC", expression.this, unit_sql, expression.args.get("zone"))
+
         def mod_sql(self, expression: exp.Mod) -> str:
             this = expression.this
             expr = expression.expression

sqlglot/dialects/clickhouse.py

@@ -297,6 +297,7 @@ class ClickHouse(Dialect):
         MODIFIERS_ATTACHED_TO_SET_OP = False
         INTERVAL_SPANS = False
         OPTIONAL_ALIAS_TOKEN_CTE = False
+        JOINS_HAVE_EQUAL_PRECEDENCE = True
 
         FUNCTIONS = {
             **parser.Parser.FUNCTIONS,
@@ -691,6 +692,7 @@ class ClickHouse(Dialect):
             parse_bracket: bool = False,
             is_db_reference: bool = False,
             parse_partition: bool = False,
+            consume_pipe: bool = False,
         ) -> t.Optional[exp.Expression]:
             this = super()._parse_table(
                 schema=schema,

sqlglot/dialects/databricks.py

@@ -9,6 +9,7 @@ from sqlglot.dialects.dialect import (
     build_date_delta,
     timestamptrunc_sql,
     build_formatted_time,
+    groupconcat_sql,
 )
 from sqlglot.dialects.spark import Spark
 from sqlglot.tokens import TokenType
@@ -87,6 +88,7 @@ class Databricks(Spark):
                 e.this,
             ),
             exp.DatetimeTrunc: timestamptrunc_sql(),
+            exp.GroupConcat: groupconcat_sql,
             exp.Select: transforms.preprocess(
                 [
                     transforms.eliminate_distinct_on,

sqlglot/dialects/dialect.py

@@ -77,6 +77,7 @@ class Dialects(str, Enum):
     DRUID = "druid"
     DUCKDB = "duckdb"
     DUNE = "dune"
+    FABRIC = "fabric"
     HIVE = "hive"
     MATERIALIZE = "materialize"
     MYSQL = "mysql"
@@ -95,6 +96,7 @@ class Dialects(str, Enum):
     TERADATA = "teradata"
     TRINO = "trino"
     TSQL = "tsql"
+    EXASOL = "exasol"
 
 
 class NormalizationStrategy(str, AutoName):
@@ -699,6 +701,9 @@ class Dialect(metaclass=_Dialect):
             exp.TimeAdd,
             exp.TimeSub,
         },
+        exp.DataType.Type.TIMESTAMPTZ: {
+            exp.CurrentTimestampLTZ,
+        },
         exp.DataType.Type.TIMESTAMP: {
             exp.CurrentTimestamp,
             exp.StrToTime,
@@ -1905,14 +1910,23 @@ def groupconcat_sql(
 
 
 def build_timetostr_or_tochar(args: t.List, dialect: Dialect) -> exp.TimeToStr | exp.ToChar:
-    this = seq_get(args, 0)
+    if len(args) == 2:
+        this = args[0]
+        if not this.type:
+            from sqlglot.optimizer.annotate_types import annotate_types
 
-    if this and not this.type:
-        from sqlglot.optimizer.annotate_types import annotate_types
+            annotate_types(this, dialect=dialect)
 
-        annotate_types(this, dialect=dialect)
         if this.is_type(*exp.DataType.TEMPORAL_TYPES):
             dialect_name = dialect.__class__.__name__.lower()
             return build_formatted_time(exp.TimeToStr, dialect_name, default=True)(args)
 
     return exp.ToChar.from_arg_list(args)
+
+
+def build_replace_with_optional_replacement(args: t.List) -> exp.Replace:
+    return exp.Replace(
+        this=seq_get(args, 0),
+        expression=seq_get(args, 1),
+        replacement=seq_get(args, 2) or exp.Literal.string(""),
+    )

sqlglot/dialects/duckdb.py

@@ -508,6 +508,7 @@ class DuckDB(Dialect):
             parse_bracket: bool = False,
             is_db_reference: bool = False,
             parse_partition: bool = False,
+            consume_pipe: bool = False,
         ) -> t.Optional[exp.Expression]:
             # DuckDB supports prefix aliases, e.g. FROM foo: bar
             if self._next and self._next.token_type == TokenType.COLON:

sqlglot/dialects/exasol.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+from sqlglot import exp, generator
+from sqlglot.dialects.dialect import Dialect, rename_func
+
+
+class Exasol(Dialect):
+    class Generator(generator.Generator):
+        # https://docs.exasol.com/db/latest/sql_references/data_types/datatypedetails.htm#StringDataType
+        STRING_TYPE_MAPPING = {
+            exp.DataType.Type.BLOB: "VARCHAR",
+            exp.DataType.Type.LONGBLOB: "VARCHAR",
+            exp.DataType.Type.LONGTEXT: "VARCHAR",
+            exp.DataType.Type.MEDIUMBLOB: "VARCHAR",
+            exp.DataType.Type.MEDIUMTEXT: "VARCHAR",
+            exp.DataType.Type.TINYBLOB: "VARCHAR",
+            exp.DataType.Type.TINYTEXT: "VARCHAR",
+            exp.DataType.Type.TEXT: "VARCHAR",
+            exp.DataType.Type.VARBINARY: "VARCHAR",
+        }
+
+        # https://docs.exasol.com/db/latest/sql_references/data_types/datatypealiases.htm
+        TYPE_MAPPING = {
+            **generator.Generator.TYPE_MAPPING,
+            **STRING_TYPE_MAPPING,
+            exp.DataType.Type.TINYINT: "SMALLINT",
+            exp.DataType.Type.MEDIUMINT: "INT",
+            exp.DataType.Type.DECIMAL32: "DECIMAL",
+            exp.DataType.Type.DECIMAL64: "DECIMAL",
+            exp.DataType.Type.DECIMAL128: "DECIMAL",
+            exp.DataType.Type.DECIMAL256: "DECIMAL",
+            exp.DataType.Type.DATETIME: "TIMESTAMP",
+        }
+
+        def datatype_sql(self, expression: exp.DataType) -> str:
+            # Exasol supports a fixed default precision of 3 for TIMESTAMP WITH LOCAL TIME ZONE
+            # and does not allow specifying a different custom precision
+            if expression.is_type(exp.DataType.Type.TIMESTAMPLTZ):
+                return "TIMESTAMP WITH LOCAL TIME ZONE"
+
+            return super().datatype_sql(expression)
+
+        TRANSFORMS = {
+            **generator.Generator.TRANSFORMS,
+            # https://docs.exasol.com/db/latest/sql_references/functions/alphabeticallistfunctions/mod.htm
+            exp.Mod: rename_func("MOD"),
+        }

sqlglot/dialects/fabric.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+
+from sqlglot import exp
+from sqlglot.dialects.dialect import NormalizationStrategy
+from sqlglot.dialects.tsql import TSQL
+from sqlglot.tokens import TokenType
+
+
+class Fabric(TSQL):
+    """
+    Microsoft Fabric Data Warehouse dialect that inherits from T-SQL.
+
+    Microsoft Fabric is a cloud-based analytics platform that provides a unified
+    data warehouse experience. While it shares much of T-SQL's syntax, it has
+    specific differences and limitations that this dialect addresses.
+
+    Key differences from T-SQL:
+    - Case-sensitive identifiers (unlike T-SQL which is case-insensitive)
+    - Limited data type support with mappings to supported alternatives
+    - Temporal types (DATETIME2, DATETIMEOFFSET, TIME) limited to 6 digits precision
+    - Certain legacy types (MONEY, SMALLMONEY, etc.) are not supported
+    - Unicode types (NCHAR, NVARCHAR) are mapped to non-unicode equivalents
+
+    References:
+    - Data Types: https://learn.microsoft.com/en-us/fabric/data-warehouse/data-types
+    - T-SQL Surface Area: https://learn.microsoft.com/en-us/fabric/data-warehouse/tsql-surface-area
+    """
+
+    # Fabric is case-sensitive unlike T-SQL which is case-insensitive
+    NORMALIZATION_STRATEGY = NormalizationStrategy.CASE_SENSITIVE
+
+    class Tokenizer(TSQL.Tokenizer):
+        # Override T-SQL tokenizer to handle TIMESTAMP differently
+        # In T-SQL, TIMESTAMP is a synonym for ROWVERSION, but in Fabric we want it to be a datetime type
+        # Also add UTINYINT keyword mapping since T-SQL doesn't have it
+        KEYWORDS = {
+            **TSQL.Tokenizer.KEYWORDS,
+            "TIMESTAMP": TokenType.TIMESTAMP,
+            "UTINYINT": TokenType.UTINYINT,
+        }
+
+    class Generator(TSQL.Generator):
+        # Fabric-specific type mappings - override T-SQL types that aren't supported
+        # Reference: https://learn.microsoft.com/en-us/fabric/data-warehouse/data-types
+        TYPE_MAPPING = {
+            **TSQL.Generator.TYPE_MAPPING,
+            exp.DataType.Type.DATETIME: "DATETIME2",
+            exp.DataType.Type.DECIMAL: "DECIMAL",
+            exp.DataType.Type.IMAGE: "VARBINARY",
+            exp.DataType.Type.INT: "INT",
+            exp.DataType.Type.JSON: "VARCHAR",
+            exp.DataType.Type.MONEY: "DECIMAL",
+            exp.DataType.Type.NCHAR: "CHAR",
+            exp.DataType.Type.NVARCHAR: "VARCHAR",
+            exp.DataType.Type.ROWVERSION: "ROWVERSION",
+            exp.DataType.Type.SMALLDATETIME: "DATETIME2",
+            exp.DataType.Type.SMALLMONEY: "DECIMAL",
+            exp.DataType.Type.TIMESTAMP: "DATETIME2",
+            exp.DataType.Type.TIMESTAMPNTZ: "DATETIME2",
+            exp.DataType.Type.TIMESTAMPTZ: "DATETIMEOFFSET",
+            exp.DataType.Type.TINYINT: "SMALLINT",
+            exp.DataType.Type.UTINYINT: "SMALLINT",
+            exp.DataType.Type.UUID: "VARBINARY(MAX)",
+            exp.DataType.Type.XML: "VARCHAR",
+        }
+
+        def datatype_sql(self, expression: exp.DataType) -> str:
+            # Check if this is a temporal type that needs precision handling. Fabric limits temporal
+            # types to max 6 digits precision. When no precision is specified, we default to 6 digits.
+            if (
+                expression.is_type(*exp.DataType.TEMPORAL_TYPES)
+                and expression.this != exp.DataType.Type.DATE
+            ):
+                # Get the current precision (first expression if it exists)
+                precision_param = expression.find(exp.DataTypeParam)
+                target_precision = 6
+
+                if precision_param and precision_param.this.is_int:
+                    # Cap precision at 6
+                    current_precision = precision_param.this.to_py()
+                    target_precision = min(current_precision, 6)
+                else:
+                    # If precision exists but is not an integer, default to 6
+                    target_precision = 6
+
+                # Create a new expression with the target precision
+                expression = exp.DataType(
+                    this=expression.this,
+                    expressions=[exp.DataTypeParam(this=exp.Literal.number(target_precision))],
+                )
+
+            return super().datatype_sql(expression)
+
+        def unixtotime_sql(self, expression: exp.UnixToTime) -> str:
+            scale = expression.args.get("scale")
+            timestamp = expression.this
+
+            if scale not in (None, exp.UnixToTime.SECONDS):
+                self.unsupported(f"UnixToTime scale {scale} is not supported by Fabric")
+                return ""
+
+            # Convert unix timestamp (seconds) to microseconds and round to avoid decimals
+            microseconds = timestamp * exp.Literal.number("1e6")
+            rounded = exp.func("round", microseconds, 0)
+            rounded_ms_as_bigint = exp.cast(rounded, exp.DataType.Type.BIGINT)
+
+            # Create the base datetime as '1970-01-01' cast to DATETIME2(6)
+            epoch_start = exp.cast("'1970-01-01'", "datetime2(6)", dialect="fabric")
+
+            dateadd = exp.DateAdd(
+                this=epoch_start,
+                expression=rounded_ms_as_bigint,
+                unit=exp.Literal.string("MICROSECONDS"),
+            )
+            return self.sql(dateadd)

sqlglot/dialects/hive.py

@@ -305,6 +305,7 @@ class Hive(Dialect):
         LOG_DEFAULTS_TO_LN = True
         STRICT_CAST = False
         VALUES_FOLLOWED_BY_PAREN = False
+        JOINS_HAVE_EQUAL_PRECEDENCE = True
 
         FUNCTIONS = {
             **parser.Parser.FUNCTIONS,

sqlglot/dialects/oracle.py

@@ -128,6 +128,7 @@ class Oracle(Dialect):
             "NEXT": lambda self: self._parse_next_value_for(),
             "PRIOR": lambda self: self.expression(exp.Prior, this=self._parse_bitwise()),
             "SYSDATE": lambda self: self.expression(exp.CurrentTimestamp, sysdate=True),
+            "DBMS_RANDOM": lambda self: self._parse_dbms_random(),
         }
 
         FUNCTION_PARSERS: t.Dict[str, t.Callable] = {
@@ -177,6 +178,19 @@ class Oracle(Dialect):
             ),
         }
 
+        def _parse_dbms_random(self) -> t.Optional[exp.Expression]:
+            if self._match_text_seq(".", "VALUE"):
+                lower, upper = None, None
+                if self._match(TokenType.L_PAREN, advance=False):
+                    lower_upper = self._parse_wrapped_csv(self._parse_bitwise)
+                    if len(lower_upper) == 2:
+                        lower, upper = lower_upper
+
+                return exp.Rand(lower=lower, upper=upper)
+
+            self._retreat(self._index - 1)
+            return None
+
         def _parse_json_array(self, expr_type: t.Type[E], **kwargs) -> E:
             return self.expression(
                 expr_type,
@@ -299,6 +313,7 @@ class Oracle(Dialect):
             exp.LogicalOr: rename_func("MAX"),
             exp.LogicalAnd: rename_func("MIN"),
             exp.Mod: rename_func("MOD"),
+            exp.Rand: rename_func("DBMS_RANDOM.VALUE"),
             exp.Select: transforms.preprocess(
                 [
                     transforms.eliminate_distinct_on,

sqlglot/dialects/presto.py

@@ -8,6 +8,7 @@ from sqlglot.dialects.dialect import (
     NormalizationStrategy,
     binary_from_function,
     bool_xor_sql,
+    build_replace_with_optional_replacement,
     date_trunc_to_time,
     datestrtodate_sql,
     encode_decode_sql,
@@ -315,6 +316,7 @@ class Presto(Dialect):
 
     class Parser(parser.Parser):
         VALUES_FOLLOWED_BY_PAREN = False
+        ZONE_AWARE_TIMESTAMP_CONSTRUCTOR = True
 
         FUNCTIONS = {
             **parser.Parser.FUNCTIONS,
@@ -359,6 +361,7 @@ class Presto(Dialect):
                 expression=seq_get(args, 1),
                 replacement=seq_get(args, 2) or exp.Literal.string(""),
             ),
+            "REPLACE": build_replace_with_optional_replacement,
             "ROW": exp.Struct.from_arg_list,
             "SEQUENCE": exp.GenerateSeries.from_arg_list,
             "SET_AGG": exp.ArrayUniqueAgg.from_arg_list,

sqlglot/dialects/prql.py

@@ -189,11 +189,15 @@ class PRQL(Dialect):
             parse_bracket: bool = False,
             is_db_reference: bool = False,
             parse_partition: bool = False,
+            consume_pipe: bool = False,
         ) -> t.Optional[exp.Expression]:
             return self._parse_table_parts()
 
         def _parse_from(
-            self, joins: bool = False, skip_from_token: bool = False
+            self,
+            joins: bool = False,
+            skip_from_token: bool = False,
+            consume_pipe: bool = False,
         ) -> t.Optional[exp.From]:
             if not skip_from_token and not self._match(TokenType.FROM):
                 return None

sqlglot/dialects/redshift.py

@@ -90,6 +90,7 @@ class Redshift(Postgres):
             parse_bracket: bool = False,
             is_db_reference: bool = False,
             parse_partition: bool = False,
+            consume_pipe: bool = False,
         ) -> t.Optional[exp.Expression]:
             # Redshift supports UNPIVOTing SUPER objects, e.g. `UNPIVOT foo.obj[0] AS val AT attr`
             unpivot = self._match(TokenType.UNPIVOT)
@@ -212,8 +213,7 @@ class Redshift(Postgres):
             exp.TableSample: no_tablesample_sql,
             exp.TsOrDsAdd: date_delta_sql("DATEADD"),
             exp.TsOrDsDiff: date_delta_sql("DATEDIFF"),
-            exp.UnixToTime: lambda self,
-            e: f"(TIMESTAMP 'epoch' + {self.sql(e.this)} * INTERVAL '1 SECOND')",
+            exp.UnixToTime: lambda self, e: self._unix_to_time_sql(e),
         }
 
         # Postgres maps exp.Pivot to no_pivot_sql, but Redshift support pivots
@@ -446,3 +446,12 @@ class Redshift(Postgres):
         def explode_sql(self, expression: exp.Explode) -> str:
             self.unsupported("Unsupported EXPLODE() function")
             return ""
+
+        def _unix_to_time_sql(self, expression: exp.UnixToTime) -> str:
+            scale = expression.args.get("scale")
+            this = self.sql(expression.this)
+
+            if scale is not None and scale != exp.UnixToTime.SECONDS and scale.is_int:
+                this = f"({this} / POWER(10, {scale.to_py()}))"
+
+            return f"(TIMESTAMP 'epoch' + {this} * INTERVAL '1 SECOND')"

sqlglot/dialects/snowflake.py

@@ -9,6 +9,7 @@ from sqlglot.dialects.dialect import (
     build_timetostr_or_tochar,
     binary_from_function,
     build_default_decimal_type,
+    build_replace_with_optional_replacement,
     build_timestamp_from_parts,
     date_delta_sql,
     date_trunc_to_time,
@@ -484,6 +485,7 @@ class Snowflake(Dialect):
             "REGEXP_REPLACE": _build_regexp_replace,
             "REGEXP_SUBSTR": _build_regexp_extract(exp.RegexpExtract),
             "REGEXP_SUBSTR_ALL": _build_regexp_extract(exp.RegexpExtractAll),
+            "REPLACE": build_replace_with_optional_replacement,
             "RLIKE": exp.RegexpLike.from_arg_list,
             "SQUARE": lambda args: exp.Pow(this=seq_get(args, 0), expression=exp.Literal.number(2)),
             "TABLE": lambda args: exp.TableFromRows(this=seq_get(args, 0)),
@@ -799,6 +801,7 @@ class Snowflake(Dialect):
             parse_bracket: bool = False,
             is_db_reference: bool = False,
             parse_partition: bool = False,
+            consume_pipe: bool = False,
         ) -> t.Optional[exp.Expression]:
             table = super()._parse_table(
                 schema=schema,
@@ -1415,7 +1418,7 @@ class Snowflake(Dialect):
 
         def timetostr_sql(self, expression: exp.TimeToStr) -> str:
             this = expression.this
-            if not isinstance(this, exp.TsOrDsToTimestamp):
+            if this.is_string:
                 this = exp.cast(this, exp.DataType.Type.TIMESTAMP)
 
             return self.func("TO_CHAR", this, self.format_time(expression))

sqlglot/dialects/spark.py

@@ -7,6 +7,7 @@ from sqlglot.dialects.dialect import rename_func, unit_to_var, timestampdiff_sql
 from sqlglot.dialects.hive import _build_with_ignore_nulls
 from sqlglot.dialects.spark2 import Spark2, temporary_storage_provider, _build_as_cast
 from sqlglot.helper import ensure_list, seq_get
+from sqlglot.tokens import TokenType
 from sqlglot.transforms import (
     ctas_with_tmp_tables_to_create_tmp_view,
     remove_unique_constraints,
@@ -121,6 +122,16 @@ class Spark(Spark2):
             ),
         }
 
+        PLACEHOLDER_PARSERS = {
+            **Spark2.Parser.PLACEHOLDER_PARSERS,
+            TokenType.L_BRACE: lambda self: self._parse_query_parameter(),
+        }
+
+        def _parse_query_parameter(self) -> t.Optional[exp.Expression]:
+            this = self._parse_id_var()
+            self._match(TokenType.R_BRACE)
+            return self.expression(exp.Placeholder, this=this, widget=True)
+
         def _parse_generated_as_identity(
             self,
         ) -> (
@@ -200,3 +211,9 @@ class Spark(Spark2):
                 return self.func("DATEDIFF", unit_to_var(expression), start, end)
 
             return self.func("DATEDIFF", end, start)
+
+        def placeholder_sql(self, expression: exp.Placeholder) -> str:
+            if not expression.args.get("widget"):
+                return super().placeholder_sql(expression)
+
+            return f"{{{expression.name}}}"

sqlglot/dialects/sqlite.py

@@ -102,6 +102,10 @@ class SQLite(Dialect):
         COMMANDS = {*tokens.Tokenizer.COMMANDS, TokenType.REPLACE}
 
     class Parser(parser.Parser):
+        STRING_ALIASES = True
+        ALTER_RENAME_REQUIRES_COLUMN = False
+        JOINS_HAVE_EQUAL_PRECEDENCE = True
+
         FUNCTIONS = {
             **parser.Parser.FUNCTIONS,
             "EDITDIST3": exp.Levenshtein.from_arg_list,
@@ -110,9 +114,6 @@ class SQLite(Dialect):
             "TIME": lambda args: exp.Anonymous(this="TIME", expressions=args),
         }
 
-        STRING_ALIASES = True
-        ALTER_RENAME_REQUIRES_COLUMN = False
-
         def _parse_unique(self) -> exp.UniqueColumnConstraint:
             # Do not consume more tokens if UNIQUE is used as a standalone constraint, e.g:
             # CREATE TABLE foo (bar TEXT UNIQUE REFERENCES baz ...)

sqlglot/dialects/tsql.py

@@ -612,6 +612,7 @@ class TSQL(Dialect):
             "SYSDATETIME": exp.CurrentTimestamp.from_arg_list,
             "SUSER_NAME": exp.CurrentUser.from_arg_list,
             "SUSER_SNAME": exp.CurrentUser.from_arg_list,
+            "SYSDATETIMEOFFSET": exp.CurrentTimestampLTZ.from_arg_list,
             "SYSTEM_USER": exp.CurrentUser.from_arg_list,
             "TIMEFROMPARTS": _build_timefromparts,
             "DATETRUNC": _build_datetrunc,
@@ -1020,6 +1021,7 @@ class TSQL(Dialect):
             exp.CTE: transforms.preprocess([qualify_derived_table_outputs]),
             exp.CurrentDate: rename_func("GETDATE"),
             exp.CurrentTimestamp: rename_func("GETDATE"),
+            exp.CurrentTimestampLTZ: rename_func("SYSDATETIMEOFFSET"),
             exp.DateStrToDate: datestrtodate_sql,
             exp.Extract: rename_func("DATEPART"),
             exp.GeneratedAsIdentityColumnConstraint: generatedasidentitycolumnconstraint_sql,
@@ -1249,15 +1251,15 @@ class TSQL(Dialect):
                 sql_with_ctes = self.prepend_ctes(expression, sql)
                 sql_literal = self.sql(exp.Literal.string(sql_with_ctes))
                 if kind == "SCHEMA":
-                    return f"""IF NOT EXISTS (SELECT * FROM information_schema.schemata WHERE schema_name = {identifier}) EXEC({sql_literal})"""
+                    return f"""IF NOT EXISTS (SELECT * FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME = {identifier}) EXEC({sql_literal})"""
                 elif kind == "TABLE":
                     assert table
                     where = exp.and_(
-                        exp.column("table_name").eq(table.name),
-                        exp.column("table_schema").eq(table.db) if table.db else None,
-                        exp.column("table_catalog").eq(table.catalog) if table.catalog else None,
+                        exp.column("TABLE_NAME").eq(table.name),
+                        exp.column("TABLE_SCHEMA").eq(table.db) if table.db else None,
+                        exp.column("TABLE_CATALOG").eq(table.catalog) if table.catalog else None,
                     )
-                    return f"""IF NOT EXISTS (SELECT * FROM information_schema.tables WHERE {where}) EXEC({sql_literal})"""
+                    return f"""IF NOT EXISTS (SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE {where}) EXEC({sql_literal})"""
                 elif kind == "INDEX":
                     index = self.sql(exp.Literal.string(expression.this.text("this")))
                     return f"""IF NOT EXISTS (SELECT * FROM sys.indexes WHERE object_id = object_id({identifier}) AND name = {index}) EXEC({sql_literal})"""

sqlglot/expressions.py

@@ -4453,8 +4453,9 @@ class SessionParameter(Condition):
     arg_types = {"this": True, "kind": False}
 
 
+# https://www.databricks.com/blog/parameterized-queries-pyspark
 class Placeholder(Condition):
-    arg_types = {"this": False, "kind": False}
+    arg_types = {"this": False, "kind": False, "widget": False}
 
     @property
     def name(self) -> str:
@@ -5805,6 +5806,10 @@ class CurrentTimestamp(Func):
     arg_types = {"this": False, "sysdate": False}
 
 
+class CurrentTimestampLTZ(Func):
+    arg_types = {}
+
+
 class CurrentSchema(Func):
     arg_types = {"this": False}
 
@@ -5845,8 +5850,6 @@ class DateTrunc(Func):
                 unit_name = TimeUnit.UNABBREVIATED_UNIT_NAME[unit_name]
 
             args["unit"] = Literal.string(unit_name)
-        elif isinstance(unit, Week):
-            unit.set("this", Literal.string(unit.this.name.upper()))
 
         super().__init__(**args)
 
@@ -6668,6 +6671,11 @@ class Repeat(Func):
     arg_types = {"this": True, "times": True}
 
 
+# Some dialects like Snowflake support two argument replace
+class Replace(Func):
+    arg_types = {"this": True, "expression": True, "replacement": False}
+
+
 # https://learn.microsoft.com/en-us/sql/t-sql/functions/round-transact-sql?view=sql-server-ver16
 # tsql third argument function == trunctaion if not 0
 class Round(Func):

sqlglot/generator.py

@@ -3480,7 +3480,7 @@ class Generator(metaclass=_Generator):
 
                 actions_list.append(action_sql)
 
-            actions_sql = self.format_args(*actions_list)
+            actions_sql = self.format_args(*actions_list).lstrip("\n")
 
         exists = " IF EXISTS" if expression.args.get("exists") else ""
         on_cluster = self.sql(expression, "cluster")
@@ -3491,7 +3491,7 @@ class Generator(metaclass=_Generator):
         kind = self.sql(expression, "kind")
         not_valid = " NOT VALID" if expression.args.get("not_valid") else ""
 
-        return f"ALTER {kind}{exists}{only} {self.sql(expression, 'this')}{on_cluster} {actions_sql}{not_valid}{options}"
+        return f"ALTER {kind}{exists}{only} {self.sql(expression, 'this')}{on_cluster}{self.sep()}{actions_sql}{not_valid}{options}"
 
     def add_column_sql(self, expression: exp.Expression) -> str:
         sql = self.sql(expression)
@@ -3510,7 +3510,7 @@ class Generator(metaclass=_Generator):
         return f"DROP{exists}{expressions}"
 
     def addconstraint_sql(self, expression: exp.AddConstraint) -> str:
-        return f"ADD {self.expressions(expression)}"
+        return f"ADD {self.expressions(expression, indent=False)}"
 
     def addpartition_sql(self, expression: exp.AddPartition) -> str:
         exists = "IF NOT EXISTS " if expression.args.get("exists") else ""

sqlglot/optimizer/scope.py

@@ -358,7 +358,7 @@ class Scope:
             for expression in itertools.chain(self.derived_tables, self.udtfs):
                 self._references.append(
                     (
-                        expression.alias,
+                        _get_source_alias(expression),
                         expression if expression.args.get("pivots") else expression.unnest(),
                     )
                 )
@@ -785,7 +785,7 @@ def _traverse_tables(scope):
             # This shouldn't be a problem once qualify_columns runs, as it adds aliases on everything.
             # Until then, this means that only a single, unaliased derived table is allowed (rather,
             # the latest one wins.
-            sources[expression.alias] = child_scope
+            sources[_get_source_alias(expression)] = child_scope
 
         # append the final child_scope yielded
         if child_scope:
@@ -825,7 +825,7 @@ def _traverse_udtfs(scope):
             ):
                 yield child_scope
                 top = child_scope
-                sources[expression.alias] = child_scope
+                sources[_get_source_alias(expression)] = child_scope
 
             scope.subquery_scopes.append(top)
 
@@ -915,3 +915,13 @@ def find_in_scope(expression, expression_types, bfs=True):
         the criteria was found.
     """
     return next(find_all_in_scope(expression, expression_types, bfs=bfs), None)
+
+
+def _get_source_alias(expression):
+    alias_arg = expression.args.get("alias")
+    alias_name = expression.alias
+
+    if not alias_name and isinstance(alias_arg, exp.TableAlias) and len(alias_arg.columns) == 1:
+        alias_name = alias_arg.columns[0].name
+
+    return alias_name

sqlglot/parser.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import logging
+import re
 import typing as t
 import itertools
 from collections import defaultdict
@@ -23,6 +24,9 @@ logger = logging.getLogger("sqlglot")
 
 OPTIONS_TYPE = t.Dict[str, t.Sequence[t.Union[t.Sequence[str], str]]]
 
+# Used to detect alphabetical characters and +/- in timestamp literals
+TIME_ZONE_RE: t.Pattern[str] = re.compile(r":.*?[a-zA-Z\+\-]")
+
 
 def build_var_map(args: t.List) -> exp.StarMap | exp.VarMap:
     if len(args) == 1 and args[0].is_star:
@@ -935,7 +939,6 @@ class Parser(metaclass=_Parser):
         "AS": lambda self, query: self._build_pipe_cte(
             query, [exp.Star()], self._parse_table_alias()
         ),
-        "DROP": lambda self, query: self._parse_pipe_syntax_drop(query),
         "EXTEND": lambda self, query: self._parse_pipe_syntax_extend(query),
         "LIMIT": lambda self, query: self._parse_pipe_syntax_limit(query),
         "ORDER BY": lambda self, query: query.order_by(
@@ -943,7 +946,6 @@ class Parser(metaclass=_Parser):
         ),
         "PIVOT": lambda self, query: self._parse_pipe_syntax_pivot(query),
         "SELECT": lambda self, query: self._parse_pipe_syntax_select(query),
-        "SET": lambda self, query: self._parse_pipe_syntax_set(query),
         "TABLESAMPLE": lambda self, query: self._parse_pipe_syntax_tablesample(query),
         "UNPIVOT": lambda self, query: self._parse_pipe_syntax_pivot(query),
         "WHERE": lambda self, query: query.where(self._parse_where(), copy=False),
@@ -1518,6 +1520,15 @@ class Parser(metaclass=_Parser):
     # Whether renaming a column with an ALTER statement requires the presence of the COLUMN keyword
     ALTER_RENAME_REQUIRES_COLUMN = True
 
+    # Whether all join types have the same precedence, i.e., they "naturally" produce a left-deep tree.
+    # In standard SQL, joins that use the JOIN keyword take higher precedence than comma-joins. That is
+    # to say, JOIN operators happen before comma operators. This is not the case in some dialects, such
+    # as BigQuery, where all joins have the same precedence.
+    JOINS_HAVE_EQUAL_PRECEDENCE = False
+
+    # Whether TIMESTAMP <literal> can produce a zone-aware timestamp
+    ZONE_AWARE_TIMESTAMP_CONSTRUCTOR = False
+
     __slots__ = (
         "error_level",
         "error_message_context",
@@ -3142,7 +3153,7 @@ class Parser(metaclass=_Parser):
                 is_unpivot=self._prev.token_type == TokenType.UNPIVOT
             )
         elif self._match(TokenType.FROM):
-            from_ = self._parse_from(skip_from_token=True)
+            from_ = self._parse_from(skip_from_token=True, consume_pipe=True)
             # Support parentheses for duckdb FROM-first syntax
             select = self._parse_select()
             if select:
@@ -3152,7 +3163,7 @@ class Parser(metaclass=_Parser):
                 this = exp.select("*").from_(t.cast(exp.From, from_))
         else:
             this = (
-                self._parse_table()
+                self._parse_table(consume_pipe=True)
                 if table
                 else self._parse_select(nested=True, parse_set_operation=False)
             )
@@ -3173,6 +3184,31 @@ class Parser(metaclass=_Parser):
         table: bool = False,
         parse_subquery_alias: bool = True,
         parse_set_operation: bool = True,
+        consume_pipe: bool = True,
+    ) -> t.Optional[exp.Expression]:
+        query = self._parse_select_query(
+            nested=nested,
+            table=table,
+            parse_subquery_alias=parse_subquery_alias,
+            parse_set_operation=parse_set_operation,
+        )
+
+        if (
+            consume_pipe
+            and self._match(TokenType.PIPE_GT, advance=False)
+            and isinstance(query, exp.Query)
+        ):
+            query = self._parse_pipe_syntax_query(query)
+            query = query.subquery(copy=False) if query and table else query
+
+        return query
+
+    def _parse_select_query(
+        self,
+        nested: bool = False,
+        table: bool = False,
+        parse_subquery_alias: bool = True,
+        parse_set_operation: bool = True,
     ) -> t.Optional[exp.Expression]:
         cte = self._parse_with()
 
@@ -3192,7 +3228,11 @@ class Parser(metaclass=_Parser):
             return this
 
         # duckdb supports leading with FROM x
-        from_ = self._parse_from() if self._match(TokenType.FROM, advance=False) else None
+        from_ = (
+            self._parse_from(consume_pipe=True)
+            if self._match(TokenType.FROM, advance=False)
+            else None
+        )
 
         if self._match(TokenType.SELECT):
             comments = self._prev_comments
@@ -3260,8 +3300,6 @@ class Parser(metaclass=_Parser):
             this = self._parse_derived_table_values()
         elif from_:
             this = exp.select("*").from_(from_.this, copy=False)
-            if self._match(TokenType.PIPE_GT, advance=False):
-                return self._parse_pipe_syntax_query(this)
         elif self._match(TokenType.SUMMARIZE):
             table = self._match(TokenType.TABLE)
             this = self._parse_select() or self._parse_string() or self._parse_table()
@@ -3521,13 +3559,18 @@ class Parser(metaclass=_Parser):
         )
 
     def _parse_from(
-        self, joins: bool = False, skip_from_token: bool = False
+        self,
+        joins: bool = False,
+        skip_from_token: bool = False,
+        consume_pipe: bool = False,
     ) -> t.Optional[exp.From]:
         if not skip_from_token and not self._match(TokenType.FROM):
             return None
 
         return self.expression(
-            exp.From, comments=self._prev_comments, this=self._parse_table(joins=joins)
+            exp.From,
+            comments=self._prev_comments,
+            this=self._parse_table(joins=joins, consume_pipe=consume_pipe),
         )
 
     def _parse_match_recognize_measure(self) -> exp.MatchRecognizeMeasure:
@@ -3702,9 +3745,12 @@ class Parser(metaclass=_Parser):
     ) -> t.Optional[exp.Join]:
         if self._match(TokenType.COMMA):
             table = self._try_parse(self._parse_table)
-            if table:
-                return self.expression(exp.Join, this=table)
-            return None
+            cross_join = self.expression(exp.Join, this=table) if table else None
+
+            if cross_join and self.JOINS_HAVE_EQUAL_PRECEDENCE:
+                cross_join.set("kind", "CROSS")
+
+            return cross_join
 
         index = self._index
         method, side, kind = self._parse_join_parts()
@@ -3953,6 +3999,7 @@ class Parser(metaclass=_Parser):
         parse_bracket: bool = False,
         is_db_reference: bool = False,
         parse_partition: bool = False,
+        consume_pipe: bool = False,
     ) -> t.Optional[exp.Expression]:
         lateral = self._parse_lateral()
         if lateral:
@@ -3966,7 +4013,7 @@ class Parser(metaclass=_Parser):
         if values:
             return values
 
-        subquery = self._parse_select(table=True)
+        subquery = self._parse_select(table=True, consume_pipe=consume_pipe)
         if subquery:
             if not subquery.args.get("pivots"):
                 subquery.set("pivots", self._parse_pivots())
@@ -4708,7 +4755,9 @@ class Parser(metaclass=_Parser):
 
         return locks
 
-    def parse_set_operation(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
+    def parse_set_operation(
+        self, this: t.Optional[exp.Expression], consume_pipe: bool = False
+    ) -> t.Optional[exp.Expression]:
         start = self._index
         _, side_token, kind_token = self._parse_join_parts()
 
@@ -4751,7 +4800,9 @@ class Parser(metaclass=_Parser):
         if by_name and self._match_texts(("ON", "BY")):
             on_column_list = self._parse_wrapped_csv(self._parse_column)
 
-        expression = self._parse_select(nested=True, parse_set_operation=False)
+        expression = self._parse_select(
+            nested=True, parse_set_operation=False, consume_pipe=consume_pipe
+        )
 
         return self.expression(
             operation,
@@ -5082,12 +5133,20 @@ class Parser(metaclass=_Parser):
             this = self._parse_primary()
 
             if isinstance(this, exp.Literal):
+                literal = this.name
                 this = self._parse_column_ops(this)
 
                 parser = self.TYPE_LITERAL_PARSERS.get(data_type.this)
                 if parser:
                     return parser(self, this, data_type)
 
+                if (
+                    self.ZONE_AWARE_TIMESTAMP_CONSTRUCTOR
+                    and data_type.is_type(exp.DataType.Type.TIMESTAMP)
+                    and TIME_ZONE_RE.search(literal)
+                ):
+                    data_type = exp.DataType.build("TIMESTAMPTZ")
+
                 return self.expression(exp.Cast, this=this, to=data_type)
 
             # The expressions arg gets set by the parser when we have something like DECIMAL(38, 0)
@@ -7303,8 +7362,9 @@ class Parser(metaclass=_Parser):
 
             return None
 
-        if not self.dialect.ALTER_TABLE_ADD_REQUIRED_FOR_EACH_COLUMN or self._match_text_seq(
-            "COLUMNS"
+        if not self._match_set(self.ADD_CONSTRAINT_TOKENS, advance=False) and (
+            not self.dialect.ALTER_TABLE_ADD_REQUIRED_FOR_EACH_COLUMN
+            or self._match_text_seq("COLUMNS")
         ):
             schema = self._parse_schema()
 
@@ -8361,34 +8421,14 @@ class Parser(metaclass=_Parser):
 
         return new_select.with_(new_cte, as_=query, copy=False)
 
-    def _build_pipe_ctes(
-        self,
-        query: exp.Select,
-        expressions: t.List[exp.Expression],
-        alias_cte: t.Optional[exp.TableAlias] = None,
-    ) -> exp.Select:
-        select = query.selects[0].assert_is(exp.Star)
-        if select.args.get("except") or select.args.get("replace"):
-            query = self._build_pipe_cte(
-                query=query.select(
-                    *[expr for expr in expressions if not expr.is_star and expr.args.get("alias")],
-                    copy=False,
-                ),
-                expressions=[
-                    projection.args.get("alias", projection) for projection in expressions
-                ],
-            )
-        else:
-            query.select(*expressions, append=False, copy=False)
-
-        return self._build_pipe_cte(query=query, expressions=[exp.Star()], alias_cte=alias_cte)
-
     def _parse_pipe_syntax_select(self, query: exp.Select) -> exp.Select:
-        select = self._parse_select()
+        select = self._parse_select(consume_pipe=False)
         if not select:
             return query
 
-        return self._build_pipe_ctes(query=query, expressions=select.expressions)
+        return self._build_pipe_cte(
+            query=query.select(*select.expressions, append=False), expressions=[exp.Star()]
+        )
 
     def _parse_pipe_syntax_limit(self, query: exp.Select) -> exp.Select:
         limit = self._parse_limit()
@@ -8437,7 +8477,7 @@ class Parser(metaclass=_Parser):
                 copy=False,
             )
         else:
-            query.select(*aggregates_or_groups, copy=False)
+            query.select(*aggregates_or_groups, append=False, copy=False)
 
         if orders:
             return query.order_by(*orders, append=False, copy=False)
@@ -8453,11 +8493,9 @@ class Parser(metaclass=_Parser):
         ):
             query = self._parse_pipe_syntax_aggregate_group_order_by(query)
 
-        return self._build_pipe_ctes(
-            query=query, expressions=[expr for expr in query.selects if not expr.is_star]
-        )
+        return self._build_pipe_cte(query=query, expressions=[exp.Star()])
 
-    def _parse_pipe_syntax_set_operator(self, query: exp.Query) -> t.Optional[exp.Select]:
+    def _parse_pipe_syntax_set_operator(self, query: exp.Query) -> t.Optional[exp.Query]:
         first_setop = self.parse_set_operation(this=query)
         if not first_setop:
             return None
@@ -8488,12 +8526,15 @@ class Parser(metaclass=_Parser):
 
         return self._build_pipe_cte(query=query, expressions=[exp.Star()])
 
-    def _parse_pipe_syntax_join(self, query: exp.Select) -> t.Optional[exp.Select]:
+    def _parse_pipe_syntax_join(self, query: exp.Query) -> t.Optional[exp.Query]:
         join = self._parse_join()
         if not join:
             return None
 
-        return query.join(join, copy=False)
+        if isinstance(query, exp.Select):
+            return query.join(join, copy=False)
+
+        return query
 
     def _parse_pipe_syntax_pivot(self, query: exp.Select) -> exp.Select:
         pivots = self._parse_pivots()
@@ -8504,37 +8545,12 @@ class Parser(metaclass=_Parser):
         if from_:
             from_.this.set("pivots", pivots)
 
-        return self._build_pipe_ctes(query=query, expressions=[exp.Star()])
+        return self._build_pipe_cte(query=query, expressions=[exp.Star()])
 
     def _parse_pipe_syntax_extend(self, query: exp.Select) -> exp.Select:
         self._match_text_seq("EXTEND")
-        return self._build_pipe_ctes(
-            query=query,
-            expressions=[query.selects[0].assert_is(exp.Star), *self._parse_expressions()],
-        )
-
-    def _parse_pipe_syntax_drop(self, query: exp.Select) -> exp.Select:
-        self._match_text_seq("DROP")
-        dropped_columns = self._parse_csv(self._parse_assignment)
-
-        select = query.selects[0].assert_is(exp.Star)
-        except_ = select.args.get("except") or []
-        select.set("except", [*except_, *dropped_columns])
-
-        return query
-
-    def _parse_pipe_syntax_set(self, query: exp.Select) -> exp.Select:
-        self._match_text_seq("SET")
-        replaced_columns = [
-            self.expression(exp.Alias, this=expr.expression, alias=expr.this)
-            for expr in self._parse_csv(self._parse_assignment)
-        ]
-
-        select = query.selects[0].assert_is(exp.Star)
-        replace_ = select.args.get("replace") or []
-        select.set("replace", [*replace_, *replaced_columns])
-
-        return query
+        query.select(*[exp.Star(), *self._parse_expressions()], append=False, copy=False)
+        return self._build_pipe_cte(query=query, expressions=[exp.Star()])
 
     def _parse_pipe_syntax_tablesample(self, query: exp.Select) -> exp.Select:
         sample = self._parse_table_sample()
@@ -8547,7 +8563,13 @@ class Parser(metaclass=_Parser):
 
         return query
 
-    def _parse_pipe_syntax_query(self, query: exp.Select) -> t.Optional[exp.Select]:
+    def _parse_pipe_syntax_query(self, query: exp.Query) -> t.Optional[exp.Query]:
+        if isinstance(query, exp.Subquery):
+            query = exp.select("*").from_(query, copy=False)
+
+        if not query.args.get("from"):
+            query = exp.select("*").from_(query.subquery(copy=False), copy=False)
+
         while self._match(TokenType.PIPE_GT):
             start = self._curr
             parser = self.PIPE_SYNTAX_TRANSFORM_PARSERS.get(self._curr.text.upper())

sqlglot/transforms.py

@@ -352,13 +352,20 @@ def unnest_to_explode(
             has_multi_expr = len(exprs) > 1
             this, *expressions = _unnest_zip_exprs(unnest, exprs, has_multi_expr)
 
+            columns = alias.columns if alias else []
+            offset = unnest.args.get("offset")
+            if offset:
+                columns.insert(
+                    0, offset if isinstance(offset, exp.Identifier) else exp.to_identifier("pos")
+                )
+
             unnest.replace(
                 exp.Table(
                     this=_udtf_type(unnest, has_multi_expr)(
                         this=this,
                         expressions=expressions,
                     ),
-                    alias=exp.TableAlias(this=alias.this, columns=alias.columns) if alias else None,
+                    alias=exp.TableAlias(this=alias.this, columns=columns) if alias else None,
                 )
             )
 
@@ -393,6 +400,13 @@ def unnest_to_explode(
                         "CROSS JOIN UNNEST to LATERAL VIEW EXPLODE transformation requires explicit column aliases"
                     )
 
+                offset = unnest.args.get("offset")
+                if offset:
+                    alias_cols.insert(
+                        0,
+                        offset if isinstance(offset, exp.Identifier) else exp.to_identifier("pos"),
+                    )
+
                 for e, column in zip(exprs, alias_cols):
                     expression.append(
                         "laterals",

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlglot
-Version: 26.29.0
+Version: 26.31.0
 Summary: An easily customizable SQL parser and transpiler
 Author-email: Toby Mao <toby.mao@gmail.com>
 License: MIT License
@@ -61,7 +61,7 @@ Dynamic: provides-extra
 
 ![SQLGlot logo](sqlglot.png)
 
-SQLGlot is a no-dependency SQL parser, transpiler, optimizer, and engine. It can be used to format SQL or translate between [27 different dialects](https://github.com/tobymao/sqlglot/blob/main/sqlglot/dialects/__init__.py) like [DuckDB](https://duckdb.org/), [Presto](https://prestodb.io/) / [Trino](https://trino.io/), [Spark](https://spark.apache.org/) / [Databricks](https://www.databricks.com/), [Snowflake](https://www.snowflake.com/en/), and [BigQuery](https://cloud.google.com/bigquery/). It aims to read a wide variety of SQL inputs and output syntactically and semantically correct SQL in the targeted dialects.
+SQLGlot is a no-dependency SQL parser, transpiler, optimizer, and engine. It can be used to format SQL or translate between [29 different dialects](https://github.com/tobymao/sqlglot/blob/main/sqlglot/dialects/__init__.py) like [DuckDB](https://duckdb.org/), [Presto](https://prestodb.io/) / [Trino](https://trino.io/), [Spark](https://spark.apache.org/) / [Databricks](https://www.databricks.com/), [Snowflake](https://www.snowflake.com/en/), and [BigQuery](https://cloud.google.com/bigquery/). It aims to read a wide variety of SQL inputs and output syntactically and semantically correct SQL in the targeted dialects.
 
 It is a very comprehensive generic SQL parser with a robust [test suite](https://github.com/tobymao/sqlglot/blob/main/tests/). It is also quite [performant](#benchmarks), while being written purely in Python.
 

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

@@ -1,52 +1,54 @@
 sqlglot/__init__.py,sha256=za08rtdPh2v7dOpGdNomttlIVGgTrKja7rPd6sQwaTg,5391
 sqlglot/__main__.py,sha256=022c173KqxsiABWTEpUIq_tJUxuNiW7a7ABsxBXqvu8,2069
 sqlglot/_typing.py,sha256=-1HPyr3w5COlSJWqlgt8jhFk2dyMvBuvVBqIX1wyVCM,642
-sqlglot/_version.py,sha256=gOnetX1YzVEd7bBCS3U4KJPt8DHhhNA_iqdIiN8DYk4,515
+sqlglot/_version.py,sha256=X5X34o5ymsD4ydxIloUOjJGcZ-0Zi6rgP-736DtnUZ8,515
 sqlglot/diff.py,sha256=PtOllQMQa1Sw1-V2Y8eypmDqGujXYPaTOp_WLsWkAWk,17314
 sqlglot/errors.py,sha256=QNKMr-pzLUDR-tuMmn_GK6iMHUIVdb_YSJ_BhGEvuso,2126
-sqlglot/expressions.py,sha256=r3WkNufDInSqIoMasryY4W_XUV7DyIFU2G29jglFPqQ,243249
-sqlglot/generator.py,sha256=E1LjyN49nX9XfK-hysHWvpw7-qtws4xeb85sZi5x3M0,213345
+sqlglot/expressions.py,sha256=rYPkorYfWlBzPxyaodGqIkW-x6RG1gSkVjBkOfkdZiI,243434
+sqlglot/generator.py,sha256=Od0aBsKJph1wG_YhrknJAcAcVvuVIN823iyxA3KPi0Y,213383
 sqlglot/helper.py,sha256=9nZjFVRBtMKFC3EdzpDQ6jkazFO19po6BF8xHiNGZIo,15111
 sqlglot/jsonpath.py,sha256=dKdI3PNINNGimmSse2IIv-GbPN_3lXncXh_70QH7Lss,7664
 sqlglot/lineage.py,sha256=kXBDSErmZZluZx_kkrMj4MPEOAbkvcbX1tbOW7Bpl-U,15303
-sqlglot/parser.py,sha256=IXOPic_GfVXDaNRna9JbxmG-l2FjxZTIlV0wtWvWnqM,323926
+sqlglot/parser.py,sha256=Mqm77jhuF0b3hyuFPgYtLAMPkuslF64Y8iHIOPw3ZWA,324610
 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/transforms.py,sha256=3jpbHeVTLK9hmQi5f3_vmK-5jZB32_ittCkO7poxCs4,40631
+sqlglot/transforms.py,sha256=s96QMtR7rJbcLAU1I_IF1xLNxno6yvEbhERgbS5xmJ4,41164
 sqlglot/trie.py,sha256=v27uXMrHfqrXlJ6GmeTSMovsB_3o0ctnlKhdNt7W6fI,2245
-sqlglot/dialects/__init__.py,sha256=aZTLpe2SwgWqiVrRabmfV8TVLPVHFydGwb_zhcVhRss,3499
+sqlglot/dialects/__init__.py,sha256=G-YO1_zIcONWb9LjTjHX_HGzGl9Rm0sA9MX4ok6tpns,3527
 sqlglot/dialects/athena.py,sha256=gPE9ybRcbd6dVa1mrTFB_eVjsjQG36hErq5EpHyQmXo,6344
-sqlglot/dialects/bigquery.py,sha256=PIRhlNIj6I5iXPxR2_9q1OWXvy4ovVB_ae5qe8SWV80,52713
-sqlglot/dialects/clickhouse.py,sha256=0ahX0zjIwN9-RzfNyITBHs9PsgQXjL0uMRlRgYz9crI,56520
-sqlglot/dialects/databricks.py,sha256=8PoaiP8PfiBjpheRiua-rO_HzX2TRUXqc3DnlQ8zYrg,4481
-sqlglot/dialects/dialect.py,sha256=uiRHCJ2pjIea3EnRXhizNni1o-d31X02CRBuvXXne7U,68529
+sqlglot/dialects/bigquery.py,sha256=5s4hSe-PXbjeIlKhAZon-rGq4ZIywYZj1kxx213V748,52862
+sqlglot/dialects/clickhouse.py,sha256=Dc0aXwEgN8b6coXKM6P8zh3IsyrXjBajNGB-cVhnu1Y,56603
+sqlglot/dialects/databricks.py,sha256=mJN2lFpqgH95x3mtry3qWbuRf4q7NV5jbRAOspqclzY,4548
+sqlglot/dialects/dialect.py,sha256=qcpaE4cYO3v2R1cQVonpbrJOybYspnEdXSkXWxDW6d4,68921
 sqlglot/dialects/doris.py,sha256=eC7Ct-iz7p4Usz659NkelUFhm-GmVolIZy5uaBvgjaA,14397
 sqlglot/dialects/drill.py,sha256=FOh7_KjPx_77pv0DiHKZog0CcmzqeF9_PEmGnJ1ESSM,5825
 sqlglot/dialects/druid.py,sha256=kh3snZtneehNOWqs3XcPjsrhNaRbkCQ8E4hHbWJ1fHM,690
-sqlglot/dialects/duckdb.py,sha256=rARz845jDTzx8WUncAYHZeoBcVi7WvIJlGbjnNHaxZM,47965
+sqlglot/dialects/duckdb.py,sha256=oGCgK0KjwJcCKy-YOZeiQnEo4v7Zc1r5AK0tCXO2VIc,48005
 sqlglot/dialects/dune.py,sha256=gALut-fFfN2qMsr8LvZ1NQK3F3W9z2f4PwMvTMXVVVg,375
-sqlglot/dialects/hive.py,sha256=PO6DLT1kHL-U2kFfV1CsNgQFT7A32LuGN71gnTXEOfY,31728
+sqlglot/dialects/exasol.py,sha256=r2fO9FHfMV1_1M62wBGlNcQ6fHWikO4SBr8eCzxEYEY,2008
+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=llxu2LzndrsGyceTod-Leh03vuPWEUKzVHB5gQY-tY8,15313
+sqlglot/dialects/oracle.py,sha256=o6On1cYWFt6TpQYKuzo4kCz5vKb8jQr8WSwc619h3Lg,15967
 sqlglot/dialects/postgres.py,sha256=KUyMoLkm1_sZKUbdjn6bjXx9xz7sbEMKa-fl5Mzfrsk,31025
-sqlglot/dialects/presto.py,sha256=ltKbQ44efeq1HM0T8Qq0rsBSx6B6bF9RoKtUBVeoz70,33155
-sqlglot/dialects/prql.py,sha256=OF2LfDb4uzKIF7kpCfpL5G7VP1pnzLbjfW5QFUnuPvo,7803
-sqlglot/dialects/redshift.py,sha256=H8H8lGizHIAd4qLoPeFchyiGZKO1I8U_B058woukuGw,15366
+sqlglot/dialects/presto.py,sha256=dHdPv6tUO-7SAYUWnx5ftKzv6FcRvzBfiYDTlQvL2Cs,33312
+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=dP5o1sH0q5UDMxPoI5vYp1_2FQyBU7VbeYdxF1HVyEs,63398
-sqlglot/dialects/spark.py,sha256=fbmiTKAQiKqG9yE_HAxYGgQiOjdxB9tJyjOtgdqF100,7645
+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/sqlite.py,sha256=UzJwIdY1PsLArMxNt5lKvk8COHvXeo4FoqW41LqVmM8,12440
+sqlglot/dialects/sqlite.py,sha256=fwqmopeuoupD_2dh2q6rT3UFxWtFHkskZ1OXAYnPT9Q,12483
 sqlglot/dialects/starrocks.py,sha256=fHNgvq5Nz7dI4QUWCTOO5VDOYjasBxRRlcg9TbY0UZE,11235
 sqlglot/dialects/tableau.py,sha256=oIawDzUITxGCWaEMB8OaNMPWhbC3U-2y09pYPm4eazc,2190
 sqlglot/dialects/teradata.py,sha256=xWa-9kSTsT-eM1NePi_oIM1dPHmXW89GLU5Uda3_6Ao,14036
 sqlglot/dialects/trino.py,sha256=wgLsiX1NQvjGny_rgrU1e2r6kK1LD0KgaSdIDrYmjD0,4285
-sqlglot/dialects/tsql.py,sha256=kMa8hYAXp3D2-g4HzkuzHDsWeXU1WgbyZm2sNl2a8rE,54397
+sqlglot/dialects/tsql.py,sha256=dKlGmOmRFDx2MO5YebAAIK3FHorLZfzR0iqtK6xiiX4,54540
 sqlglot/executor/__init__.py,sha256=FslewzYQtQdDNg_0Ju2UaiP4vo4IMUgkfkmFsYUhcN0,2958
 sqlglot/executor/context.py,sha256=WJHJdYQCOeVXwLw0uSSrWSc25eBMn5Ix108RCvdsKRQ,3386
 sqlglot/executor/env.py,sha256=tQhU5PpTBMcxgZIFddFqxWMNPtHN0vOOz72voncY3KY,8276
@@ -69,11 +71,11 @@ sqlglot/optimizer/pushdown_projections.py,sha256=7NoK5NAUVYVhs0YnYyo6WuXfaO-BShS
 sqlglot/optimizer/qualify.py,sha256=oAPfwub7dEkrlCrsptcJWpLya4BgKhN6M5SwIs_86LY,4002
 sqlglot/optimizer/qualify_columns.py,sha256=77aScPakXYaiagnoCWk2qwMxlKuRGsFTAK9sOQuR2vY,40872
 sqlglot/optimizer/qualify_tables.py,sha256=5f5enBAh-bpNB9ewF97W9fx9h1TGXj1Ih5fncvH42sY,6486
-sqlglot/optimizer/scope.py,sha256=r-2PaO7-woaIWaWrKC88J9eTgdQardNYQ1rIXXaPr1w,30501
+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.29.0.dist-info/licenses/LICENSE,sha256=AI3__mHZfOtzY3EluR_pIYBm3_pE7TbVx7qaHxoZ114,1065
-sqlglot-26.29.0.dist-info/METADATA,sha256=rc1ouFaDp1lgiQ2W3jRFM2VNj7RUrf2drwij1_rajpg,20732
-sqlglot-26.29.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sqlglot-26.29.0.dist-info/top_level.txt,sha256=5kRskCGA_gVADF9rSfSzPdLHXqvfMusDYeHePfNY2nQ,8
-sqlglot-26.29.0.dist-info/RECORD,,
+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,,