sqlglot 26.28.1__tar.gz → 26.30.0__tar.gz

{sqlglot-26.28.1 → sqlglot-26.30.0}/CHANGELOG.md

@@ -1,6 +1,59 @@
 Changelog
 =========
 
+## [v26.29.0] - 2025-06-17
+### :boom: BREAKING CHANGES
+- due to [`4f42d95`](https://github.com/tobymao/sqlglot/commit/4f42d951363f8c43a4c414dc21d0505d9c8e48bf) - Normalize date parts in `exp.Extract` generation *(PR [#5229](https://github.com/tobymao/sqlglot/pull/5229) by [@VaggelisD](https://github.com/VaggelisD))*:
+
+  Normalize date parts in `exp.Extract` generation (#5229)
+
+- due to [`e7e38fe`](https://github.com/tobymao/sqlglot/commit/e7e38fe0e09f9affbff4ffa7023d0161e3a1ee49) - resolve table "columns" in bigquery that produce structs *(PR [#5230](https://github.com/tobymao/sqlglot/pull/5230) by [@georgesittas](https://github.com/georgesittas))*:
+
+  resolve table "columns" in bigquery that produce structs (#5230)
+
+
+### :sparkles: New Features
+- [`97f5822`](https://github.com/tobymao/sqlglot/commit/97f58226fc8815b23787b7b8699ea71f58268560) - **parser**: AS pipe syntax *(PR [#5224](https://github.com/tobymao/sqlglot/pull/5224) by [@geooo109](https://github.com/geooo109))*
+- [`a7e7fee`](https://github.com/tobymao/sqlglot/commit/a7e7feef02a77fe8606f3f482bad91230fa637f4) - **parser**: EXTEND pipe syntax *(PR [#5225](https://github.com/tobymao/sqlglot/pull/5225) by [@geooo109](https://github.com/geooo109))*
+- [`c1cb9f8`](https://github.com/tobymao/sqlglot/commit/c1cb9f8f682080f7a06c387219d79c6d068b6dbe) - **snowflake**: add autoincrement order clause support *(PR [#5223](https://github.com/tobymao/sqlglot/pull/5223) by [@dmaresma](https://github.com/dmaresma))*
+- [`91afe4c`](https://github.com/tobymao/sqlglot/commit/91afe4cfd7b3f427e4c0b298075e867b8a1bbe55) - **parser**: TABLESAMPLE pipe syntax *(PR [#5231](https://github.com/tobymao/sqlglot/pull/5231) by [@geooo109](https://github.com/geooo109))*
+- [`62da84a`](https://github.com/tobymao/sqlglot/commit/62da84acce7f44802dca26a9357a16115e21fabf) - **snowflake**: improve transpilation of unnested object lookup *(PR [#5234](https://github.com/tobymao/sqlglot/pull/5234) by [@georgesittas](https://github.com/georgesittas))*
+- [`2c60453`](https://github.com/tobymao/sqlglot/commit/2c604537ba83dee74e9ced7e216673ecc70fe487) - **parser**: DROP pipe syntax *(PR [#5226](https://github.com/tobymao/sqlglot/pull/5226) by [@geooo109](https://github.com/geooo109))*
+- [`9885729`](https://github.com/tobymao/sqlglot/commit/988572954135c68dc021b992c815024ce3debaff) - **parser**: SET pipe syntax *(PR [#5236](https://github.com/tobymao/sqlglot/pull/5236) by [@geooo109](https://github.com/geooo109))*
+
+### :bug: Bug Fixes
+- [`df73a79`](https://github.com/tobymao/sqlglot/commit/df73a79a2ca3ba859b8aba5e3d0f6ed269874a63) - **tsql**: Retain limit clause in subquery expression. *(PR [#5227](https://github.com/tobymao/sqlglot/pull/5227) by [@MarcusRisanger](https://github.com/MarcusRisanger))*
+- [`4f42d95`](https://github.com/tobymao/sqlglot/commit/4f42d951363f8c43a4c414dc21d0505d9c8e48bf) - **duckdb**: Normalize date parts in `exp.Extract` generation *(PR [#5229](https://github.com/tobymao/sqlglot/pull/5229) by [@VaggelisD](https://github.com/VaggelisD))*
+  - :arrow_lower_right: *fixes issue [#5228](https://github.com/tobymao/sqlglot/issues/5228) opened by [@greybeam-bot](https://github.com/greybeam-bot)*
+- [`1b4c083`](https://github.com/tobymao/sqlglot/commit/1b4c083fff8d7c44bf1dbba28c1225fa1e28c4d2) - **athena**: include Hive string escapes in the tokenizer *(PR [#5233](https://github.com/tobymao/sqlglot/pull/5233) by [@georgesittas](https://github.com/georgesittas))*
+  - :arrow_lower_right: *fixes issue [#5232](https://github.com/tobymao/sqlglot/issues/5232) opened by [@ligfx](https://github.com/ligfx)*
+- [`e7e38fe`](https://github.com/tobymao/sqlglot/commit/e7e38fe0e09f9affbff4ffa7023d0161e3a1ee49) - **optimizer**: resolve table "columns" in bigquery that produce structs *(PR [#5230](https://github.com/tobymao/sqlglot/pull/5230) by [@georgesittas](https://github.com/georgesittas))*
+  - :arrow_lower_right: *fixes issue [#5207](https://github.com/tobymao/sqlglot/issues/5207) opened by [@Bladieblah](https://github.com/Bladieblah)*
+- [`781539d`](https://github.com/tobymao/sqlglot/commit/781539d5cbe58142ed6688f1522fc4ed31da0a56) - **duckdb**: Generate correct DETACH syntax if IF EXISTS is set *(PR [#5235](https://github.com/tobymao/sqlglot/pull/5235) by [@erindru](https://github.com/erindru))*
+
+### :wrench: Chores
+- [`7dfb578`](https://github.com/tobymao/sqlglot/commit/7dfb5780fb242c82744dc1538077776ac624081e) - Refactor DETACH generation *(PR [#5237](https://github.com/tobymao/sqlglot/pull/5237) by [@VaggelisD](https://github.com/VaggelisD))*
+
+
+## [v26.28.1] - 2025-06-13
+### :boom: BREAKING CHANGES
+- due to [`44297f1`](https://github.com/tobymao/sqlglot/commit/44297f1c5c8c2cb16fe77c318312f417b4281708) - JOIN pipe syntax, Set Operators as CTEs *(PR [#5215](https://github.com/tobymao/sqlglot/pull/5215) by [@geooo109](https://github.com/geooo109))*:
+
+  JOIN pipe syntax, Set Operators as CTEs (#5215)
+
+
+### :sparkles: New Features
+- [`44297f1`](https://github.com/tobymao/sqlglot/commit/44297f1c5c8c2cb16fe77c318312f417b4281708) - **parser**: JOIN pipe syntax, Set Operators as CTEs *(PR [#5215](https://github.com/tobymao/sqlglot/pull/5215) by [@geooo109](https://github.com/geooo109))*
+- [`21cd3eb`](https://github.com/tobymao/sqlglot/commit/21cd3ebf5d0b57f5b102c5aadc3b24a598ebe918) - **parser**: PIVOT/UNPIVOT pipe syntax *(PR [#5222](https://github.com/tobymao/sqlglot/pull/5222) by [@geooo109](https://github.com/geooo109))*
+
+### :bug: Bug Fixes
+- [`28fed58`](https://github.com/tobymao/sqlglot/commit/28fed586a39df83aade4792217743a1a859fd039) - **optimizer**: UnboundLocalError in scope module *(commit by [@georgesittas](https://github.com/georgesittas))*
+- [`809e05a`](https://github.com/tobymao/sqlglot/commit/809e05a743d5a2904a1d6f6813f24ca7549ac7ef) - **snowflake**: preserve STRTOK_TO_ARRAY roundtrip *(commit by [@georgesittas](https://github.com/georgesittas))*
+
+### :recycle: Refactors
+- [`aac70aa`](https://github.com/tobymao/sqlglot/commit/aac70aaaa8d840c267129e2307ccb65058cef0c9) - **parser**: simpler _parse_pipe_syntax_select *(commit by [@geooo109](https://github.com/geooo109))*
+
+
 ## [v26.27.0] - 2025-06-12
 ### :boom: BREAKING CHANGES
 - due to [`ac6555b`](https://github.com/tobymao/sqlglot/commit/ac6555b4d6c162ef7b14b63307d01fd560138ea0) - preserve DIV binary operator, fixes [#5198](https://github.com/tobymao/sqlglot/pull/5198) *(PR [#5199](https://github.com/tobymao/sqlglot/pull/5199) by [@georgesittas](https://github.com/georgesittas))*:
@@ -4882,3 +4935,5 @@ Changelog
 [v26.25.3]: https://github.com/tobymao/sqlglot/compare/v26.25.2...v26.25.3
 [v26.26.0]: https://github.com/tobymao/sqlglot/compare/v26.25.3...v26.26.0
 [v26.27.0]: https://github.com/tobymao/sqlglot/compare/v26.26.0...v26.27.0
+[v26.28.1]: https://github.com/tobymao/sqlglot/compare/v26.27.1...v26.28.1
+[v26.29.0]: https://github.com/tobymao/sqlglot/compare/v26.28.1...v26.29.0

{sqlglot-26.28.1 → sqlglot-26.30.0}/PKG-INFO

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

{sqlglot-26.28.1 → sqlglot-26.30.0}/sqlglot/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '26.28.1'
-__version_tuple__ = version_tuple = (26, 28, 1)
+__version__ = version = '26.30.0'
+__version_tuple__ = version_tuple = (26, 30, 0)

{sqlglot-26.28.1 → sqlglot-26.30.0}/sqlglot/dialects/__init__.py

@@ -74,6 +74,7 @@ DIALECTS = [
     "Druid",
     "DuckDB",
     "Dune",
+    "Fabric",
     "Hive",
     "Materialize",
     "MySQL",

{sqlglot-26.28.1 → sqlglot-26.30.0}/sqlglot/dialects/athena.py

@@ -108,6 +108,7 @@ class Athena(Trino):
         """
 
         IDENTIFIERS = ['"', "`"]
+        STRING_ESCAPES = ["'", "\\"]
         KEYWORDS = {
             **Hive.Tokenizer.KEYWORDS,
             **Trino.Tokenizer.KEYWORDS,

{sqlglot-26.28.1 → sqlglot-26.30.0}/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}

{sqlglot-26.28.1 → sqlglot-26.30.0}/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-26.28.1 → sqlglot-26.30.0}/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"
@@ -1621,7 +1622,10 @@ def map_date_part(part, dialect: DialectType = Dialect):
     mapped = (
         Dialect.get_or_raise(dialect).DATE_PART_MAPPING.get(part.name.upper()) if part else None
     )
-    return exp.var(mapped) if mapped else part
+    if mapped:
+        return exp.Literal.string(mapped) if part.is_string else exp.var(mapped)
+
+    return part
 
 
 def no_last_day_sql(self: Generator, expression: exp.LastDay) -> str:
@@ -1903,12 +1907,19 @@ def groupconcat_sql(
 
 def build_timetostr_or_tochar(args: t.List, dialect: Dialect) -> exp.TimeToStr | exp.ToChar:
     this = seq_get(args, 0)
+    format = seq_get(args, 1)
 
-    if this and not this.type:
-        from sqlglot.optimizer.annotate_types import annotate_types
+    if this:
+        if 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):
+        from sqlglot.dialects import Snowflake
+
+        if this.is_type(*exp.DataType.TEMPORAL_TYPES) or (
+            isinstance(format, exp.Literal) and format.name in Snowflake.TIME_MAPPING
+        ):
             dialect_name = dialect.__class__.__name__.lower()
             return build_formatted_time(exp.TimeToStr, dialect_name, default=True)(args)
 

{sqlglot-26.28.1 → sqlglot-26.30.0}/sqlglot/dialects/duckdb.py

@@ -290,6 +290,12 @@ class DuckDB(Dialect):
     # https://duckdb.org/docs/sql/introduction.html#creating-a-new-table
     NORMALIZATION_STRATEGY = NormalizationStrategy.CASE_INSENSITIVE
 
+    DATE_PART_MAPPING = {
+        **Dialect.DATE_PART_MAPPING,
+        "DAYOFWEEKISO": "ISODOW",
+    }
+    DATE_PART_MAPPING.pop("WEEKDAY")
+
     def to_json_path(self, path: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
         if isinstance(path, exp.Literal):
             # DuckDB also supports the JSON pointer syntax, where every path starts with a `/`.
@@ -502,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:
@@ -620,6 +627,7 @@ class DuckDB(Dialect):
         PAD_FILL_PATTERN_IS_REQUIRED = True
         ARRAY_CONCAT_IS_VAR_LEN = False
         ARRAY_SIZE_DIM_REQUIRED = False
+        NORMALIZE_EXTRACT_DATE_PARTS = True
 
         TRANSFORMS = {
             **generator.Generator.TRANSFORMS,

sqlglot-26.30.0/sqlglot/dialects/fabric.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+from sqlglot import exp
+from sqlglot.dialects.dialect import NormalizationStrategy
+from sqlglot.dialects.tsql import TSQL
+
+
+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 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,
+            # Fabric doesn't support these types, map to alternatives
+            exp.DataType.Type.MONEY: "DECIMAL",
+            exp.DataType.Type.SMALLMONEY: "DECIMAL",
+            exp.DataType.Type.DATETIME: "DATETIME2(6)",
+            exp.DataType.Type.SMALLDATETIME: "DATETIME2(6)",
+            exp.DataType.Type.NCHAR: "CHAR",
+            exp.DataType.Type.NVARCHAR: "VARCHAR",
+            exp.DataType.Type.TEXT: "VARCHAR(MAX)",
+            exp.DataType.Type.IMAGE: "VARBINARY",
+            exp.DataType.Type.TINYINT: "SMALLINT",
+            exp.DataType.Type.UTINYINT: "SMALLINT",  # T-SQL parses TINYINT as UTINYINT
+            exp.DataType.Type.JSON: "VARCHAR",
+            exp.DataType.Type.XML: "VARCHAR",
+            exp.DataType.Type.UUID: "VARBINARY(MAX)",  # UNIQUEIDENTIFIER has limitations in Fabric
+            # Override T-SQL mappings that use different names in Fabric
+            exp.DataType.Type.DECIMAL: "DECIMAL",  # T-SQL uses NUMERIC
+            exp.DataType.Type.DOUBLE: "FLOAT",
+            exp.DataType.Type.INT: "INT",  # T-SQL uses INTEGER
+        }
+
+        def datatype_sql(self, expression: exp.DataType) -> str:
+            """
+            Override datatype generation to handle Fabric-specific precision limitations.
+
+            Fabric limits temporal types (TIME, DATETIME2, DATETIMEOFFSET) to max 6 digits precision.
+            When no precision is specified, we default to 6 digits.
+            """
+            if expression.is_type(
+                exp.DataType.Type.TIME,
+                exp.DataType.Type.DATETIME2,
+                exp.DataType.Type.TIMESTAMPTZ,  # DATETIMEOFFSET in Fabric
+            ):
+                # Get the current precision (first expression if it exists)
+                precision = expression.find(exp.DataTypeParam)
+
+                # Determine the target precision
+                if precision is None:
+                    # No precision specified, default to 6
+                    target_precision = 6
+                elif precision.this.is_int:
+                    # Cap precision at 6
+                    current_precision = precision.this.to_py()
+                    target_precision = min(current_precision, 6)
+
+                # Create a new expression with the target precision
+                new_expression = exp.DataType(
+                    this=expression.this,
+                    expressions=[exp.DataTypeParam(this=exp.Literal.number(target_precision))],
+                )
+
+                return super().datatype_sql(new_expression)
+
+            return super().datatype_sql(expression)

{sqlglot-26.28.1 → sqlglot-26.30.0}/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-26.28.1 → sqlglot-26.30.0}/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-26.28.1 → sqlglot-26.30.0}/sqlglot/dialects/presto.py

@@ -315,6 +315,7 @@ class Presto(Dialect):
 
     class Parser(parser.Parser):
         VALUES_FOLLOWED_BY_PAREN = False
+        ZONE_AWARE_TIMESTAMP_CONSTRUCTOR = True
 
         FUNCTIONS = {
             **parser.Parser.FUNCTIONS,

{sqlglot-26.28.1 → sqlglot-26.30.0}/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-26.28.1 → sqlglot-26.30.0}/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)

{sqlglot-26.28.1 → sqlglot-26.30.0}/sqlglot/dialects/snowflake.py

@@ -31,6 +31,7 @@ from sqlglot.dialects.dialect import (
 )
 from sqlglot.generator import unsupported_args
 from sqlglot.helper import flatten, is_float, is_int, seq_get
+from sqlglot.optimizer.scope import find_all_in_scope
 from sqlglot.tokens import TokenType
 
 if t.TYPE_CHECKING:
@@ -333,6 +334,34 @@ def _json_extract_value_array_sql(
     return self.func("TRANSFORM", json_extract, transform_lambda)
 
 
+def _eliminate_dot_variant_lookup(expression: exp.Expression) -> exp.Expression:
+    if isinstance(expression, exp.Select):
+        # This transformation is used to facilitate transpilation of BigQuery `UNNEST` operations
+        # to Snowflake. It should not affect roundtrip because `Unnest` nodes cannot be produced
+        # by Snowflake's parser.
+        #
+        # Additionally, at the time of writing this, BigQuery is the only dialect that produces a
+        # `TableAlias` node that only fills `columns` and not `this`, due to `UNNEST_COLUMN_ONLY`.
+        unnest_aliases = set()
+        for unnest in find_all_in_scope(expression, exp.Unnest):
+            unnest_alias = unnest.args.get("alias")
+            if (
+                isinstance(unnest_alias, exp.TableAlias)
+                and not unnest_alias.this
+                and len(unnest_alias.columns) == 1
+            ):
+                unnest_aliases.add(unnest_alias.columns[0].name)
+
+        if unnest_aliases:
+            for c in find_all_in_scope(expression, exp.Column):
+                if c.table in unnest_aliases:
+                    bracket_lhs = c.args["table"]
+                    bracket_rhs = exp.Literal.string(c.name)
+                    c.replace(exp.Bracket(this=bracket_lhs, expressions=[bracket_rhs]))
+
+    return expression
+
+
 class Snowflake(Dialect):
     # https://docs.snowflake.com/en/sql-reference/identifiers-syntax
     NORMALIZATION_STRATEGY = NormalizationStrategy.UPPERCASE
@@ -770,6 +799,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,
@@ -1096,6 +1126,7 @@ class Snowflake(Dialect):
                     transforms.explode_projection_to_unnest(),
                     transforms.eliminate_semi_and_anti_joins,
                     _transform_generate_date_array,
+                    _eliminate_dot_variant_lookup,
                 ]
             ),
             exp.SHA: rename_func("SHA1"),
@@ -1314,7 +1345,14 @@ class Snowflake(Dialect):
             start = f" START {start}" if start else ""
             increment = expression.args.get("increment")
             increment = f" INCREMENT {increment}" if increment else ""
-            return f"AUTOINCREMENT{start}{increment}"
+
+            order = expression.args.get("order")
+            if order is not None:
+                order_clause = " ORDER" if order else " NOORDER"
+            else:
+                order_clause = ""
+
+            return f"AUTOINCREMENT{start}{increment}{order_clause}"
 
         def cluster_sql(self, expression: exp.Cluster) -> str:
             return f"CLUSTER BY ({self.expressions(expression, flat=True)})"

{sqlglot-26.28.1 → sqlglot-26.30.0}/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-26.28.1 → sqlglot-26.30.0}/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-26.28.1 → sqlglot-26.30.0}/sqlglot/dialects/tsql.py

@@ -1224,8 +1224,6 @@ class TSQL(Dialect):
                     # to amend the AST by moving the CTEs to the CREATE VIEW statement's query.
                     ctas_expression.set("with", with_.pop())
 
-            sql = super().create_sql(expression)
-
             table = expression.find(exp.Table)
 
             # Convert CTAS statement to SELECT .. INTO ..
@@ -1243,6 +1241,8 @@ class TSQL(Dialect):
                     select_into.limit(0, copy=False)
 
                 sql = self.sql(select_into)
+            else:
+                sql = super().create_sql(expression)
 
             if exists:
                 identifier = self.sql(exp.Literal.string(exp.table_name(table) if table else ""))

{sqlglot-26.28.1 → sqlglot-26.30.0}/sqlglot/expressions.py

@@ -1947,6 +1947,7 @@ class GeneratedAsIdentityColumnConstraint(ColumnConstraintKind):
         "minvalue": False,
         "maxvalue": False,
         "cycle": False,
+        "order": False,
     }
 
 
@@ -4452,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:
@@ -7044,6 +7046,12 @@ class Semicolon(Expression):
     arg_types = {}
 
 
+# BigQuery allows SELECT t FROM t and treats the projection as a struct value. This expression
+# type is intended to be constructed by qualify so that we can properly annotate its type later
+class TableColumn(Expression):
+    pass
+
+
 def _norm_arg(arg):
     return arg.lower() if type(arg) is str else arg
 

{sqlglot-26.28.1 → sqlglot-26.30.0}/sqlglot/generator.py

@@ -201,6 +201,7 @@ class Generator(metaclass=_Generator):
         exp.StreamingTableProperty: lambda *_: "STREAMING",
         exp.StrictProperty: lambda *_: "STRICT",
         exp.SwapTable: lambda self, e: f"SWAP WITH {self.sql(e, 'this')}",
+        exp.TableColumn: lambda self, e: self.sql(e.this),
         exp.Tags: lambda self, e: f"TAG ({self.expressions(e, flat=True)})",
         exp.TemporaryProperty: lambda *_: "TEMPORARY",
         exp.TitleColumnConstraint: lambda self, e: f"TITLE {self.sql(e, 'this')}",
@@ -463,6 +464,11 @@ class Generator(metaclass=_Generator):
     # Whether to wrap <props> in `AlterSet`, e.g., ALTER ... SET (<props>)
     ALTER_SET_WRAPPED = False
 
+    # Whether to normalize the date parts in EXTRACT(<date_part> FROM <expr>) into a common representation
+    # For instance, to extract the day of week in ISO semantics, one can use ISODOW, DAYOFWEEKISO etc depending on the dialect.
+    # TODO: The normalization should be done by default once we've tested it across all dialects.
+    NORMALIZE_EXTRACT_DATE_PARTS = False
+
     # The name to generate for the JSONPath expression. If `None`, only `this` will be generated
     PARSE_JSON_NAME: t.Optional[str] = "PARSE_JSON"
 
@@ -2909,9 +2915,17 @@ class Generator(metaclass=_Generator):
         return f"NEXT VALUE FOR {self.sql(expression, 'this')}{order}"
 
     def extract_sql(self, expression: exp.Extract) -> str:
-        this = self.sql(expression, "this") if self.EXTRACT_ALLOWS_QUOTES else expression.this.name
+        from sqlglot.dialects.dialect import map_date_part
+
+        this = (
+            map_date_part(expression.this, self.dialect)
+            if self.NORMALIZE_EXTRACT_DATE_PARTS
+            else expression.this
+        )
+        this_sql = self.sql(this) if self.EXTRACT_ALLOWS_QUOTES else this.name
         expression_sql = self.sql(expression, "expression")
-        return f"EXTRACT({this} FROM {expression_sql})"
+
+        return f"EXTRACT({this_sql} FROM {expression_sql})"
 
     def trim_sql(self, expression: exp.Trim) -> str:
         trim_type = self.sql(expression, "position")
@@ -4766,7 +4780,10 @@ class Generator(metaclass=_Generator):
 
     def detach_sql(self, expression: exp.Detach) -> str:
         this = self.sql(expression, "this")
-        exists_sql = " IF EXISTS" if expression.args.get("exists") else ""
+        # the DATABASE keyword is required if IF EXISTS is set
+        # without it, DuckDB throws an error: Parser Error: syntax error at or near "exists" (Line Number: 1)
+        # ref: https://duckdb.org/docs/stable/sql/statements/attach.html#detach-syntax
+        exists_sql = " DATABASE IF EXISTS" if expression.args.get("exists") else ""
 
         return f"DETACH{exists_sql} {this}"