sqlglot 26.29.0__tar.gz → 26.31.0__tar.gz

{sqlglot-26.29.0 → sqlglot-26.31.0}/CHANGELOG.md

@@ -1,6 +1,73 @@
 Changelog
 =========
 
+## [v26.30.0] - 2025-06-21
+### :boom: BREAKING CHANGES
+- due to [`d3dc761`](https://github.com/tobymao/sqlglot/commit/d3dc761393146357a5d20c4d7992fd2a1ae5e6e2) - change comma to cross join when precedence is the same for all join types *(PR [#5240](https://github.com/tobymao/sqlglot/pull/5240) by [@georgesittas](https://github.com/georgesittas))*:
+
+  change comma to cross join when precedence is the same for all join types (#5240)
+
+- due to [`e7c217e`](https://github.com/tobymao/sqlglot/commit/e7c217ef08e5811e7dad2b3d26dbaa9f02114e38) - transpile from/to dbms_random.value *(PR [#5242](https://github.com/tobymao/sqlglot/pull/5242) by [@georgesittas](https://github.com/georgesittas))*:
+
+  transpile from/to dbms_random.value (#5242)
+
+- due to [`31814cd`](https://github.com/tobymao/sqlglot/commit/31814cddb0cf65caf29fbc45a31a9c865b7991c7) - cast constructed timestamp literal to zone-aware type if needed *(PR [#5253](https://github.com/tobymao/sqlglot/pull/5253) by [@georgesittas](https://github.com/georgesittas))*:
+
+  cast constructed timestamp literal to zone-aware type if needed (#5253)
+
+
+### :sparkles: New Features
+- [`e7c217e`](https://github.com/tobymao/sqlglot/commit/e7c217ef08e5811e7dad2b3d26dbaa9f02114e38) - **oracle**: transpile from/to dbms_random.value *(PR [#5242](https://github.com/tobymao/sqlglot/pull/5242) by [@georgesittas](https://github.com/georgesittas))*
+  - :arrow_lower_right: *addresses issue [#5241](https://github.com/tobymao/sqlglot/issues/5241) opened by [@Akshat-2512](https://github.com/Akshat-2512)*
+- [`0d19544`](https://github.com/tobymao/sqlglot/commit/0d19544317c1056b17fb089d4be9b5bddfe6feb3) - add Microsoft Fabric dialect, a case sensitive version of TSQL *(PR [#5247](https://github.com/tobymao/sqlglot/pull/5247) by [@mattiasthalen](https://github.com/mattiasthalen))*
+- [`249dbc9`](https://github.com/tobymao/sqlglot/commit/249dbc906adc6b20932dc8efe83f6f4d23ef8c1e) - **parser**: start with SELECT and nested pipe syntax *(PR [#5248](https://github.com/tobymao/sqlglot/pull/5248) by [@geooo109](https://github.com/geooo109))*
+- [`f5b5b93`](https://github.com/tobymao/sqlglot/commit/f5b5b9338eb92b7aa2c9b4c92c6138c2c05e1c40) - **fabric**: implement type mappings for unsupported Fabric types *(PR [#5249](https://github.com/tobymao/sqlglot/pull/5249) by [@mattiasthalen](https://github.com/mattiasthalen))*
+- [`78fcea1`](https://github.com/tobymao/sqlglot/commit/78fcea13b5eb1734a15a254875bc80ad8063b0b0) - **spark, databricks**: parse brackets as placeholder *(PR [#5256](https://github.com/tobymao/sqlglot/pull/5256) by [@geooo109](https://github.com/geooo109))*
+  - :arrow_lower_right: *addresses issue [#5251](https://github.com/tobymao/sqlglot/issues/5251) opened by [@aersam](https://github.com/aersam)*
+- [`7d71387`](https://github.com/tobymao/sqlglot/commit/7d7138780db82e7a75949d29282b944e739ad99d) - **fabric**: Add precision cap to temporal data types *(PR [#5250](https://github.com/tobymao/sqlglot/pull/5250) by [@mattiasthalen](https://github.com/mattiasthalen))*
+- [`e8cf793`](https://github.com/tobymao/sqlglot/commit/e8cf79305d398f25640ef3c07dd8b32997cb0167) - **duckdb**: Transpile Snowflake's TO_CHAR if format is in Snowflake.TIME_MAPPING *(PR [#5257](https://github.com/tobymao/sqlglot/pull/5257) by [@VaggelisD](https://github.com/VaggelisD))*
+  - :arrow_lower_right: *addresses issue [#5255](https://github.com/tobymao/sqlglot/issues/5255) opened by [@kyle-cheung](https://github.com/kyle-cheung)*
+
+### :bug: Bug Fixes
+- [`d3dc761`](https://github.com/tobymao/sqlglot/commit/d3dc761393146357a5d20c4d7992fd2a1ae5e6e2) - change comma to cross join when precedence is the same for all join types *(PR [#5240](https://github.com/tobymao/sqlglot/pull/5240) by [@georgesittas](https://github.com/georgesittas))*
+- [`31814cd`](https://github.com/tobymao/sqlglot/commit/31814cddb0cf65caf29fbc45a31a9c865b7991c7) - **presto**: cast constructed timestamp literal to zone-aware type if needed *(PR [#5253](https://github.com/tobymao/sqlglot/pull/5253) by [@georgesittas](https://github.com/georgesittas))*
+  - :arrow_lower_right: *fixes issue [#5252](https://github.com/tobymao/sqlglot/issues/5252) opened by [@agni-sairent](https://github.com/agni-sairent)*
+
+
+## [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))*:
@@ -4902,3 +4969,5 @@ Changelog
 [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
+[v26.30.0]: https://github.com/tobymao/sqlglot/compare/v26.29.0...v26.30.0

{sqlglot-26.29.0 → sqlglot-26.31.0}/PKG-INFO

@@ -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 → sqlglot-26.31.0}/README.md

@@ -1,6 +1,6 @@
 ![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 → sqlglot-26.31.0}/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-26.29.0 → sqlglot-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-26.29.0 → sqlglot-26.31.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}
@@ -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-26.29.0 → sqlglot-26.31.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.29.0 → sqlglot-26.31.0}/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-26.29.0 → sqlglot-26.31.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"
@@ -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-26.29.0 → sqlglot-26.31.0}/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-26.31.0/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-26.31.0/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-26.29.0 → sqlglot-26.31.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.29.0 → sqlglot-26.31.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.29.0 → sqlglot-26.31.0}/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-26.29.0 → sqlglot-26.31.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.29.0 → sqlglot-26.31.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)
@@ -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-26.29.0 → sqlglot-26.31.0}/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-26.29.0 → sqlglot-26.31.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.29.0 → sqlglot-26.31.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 ...)