Add Snowflake COPY/REVOKE CURRENT GRANTS option (#1926)

Co-authored-by: Ifeanyi Ubah <ify1992@yahoo.com>

.github/workflows/license.yml

@@ -0,0 +1,39 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+name: license
+
+# trigger for all PRs and changes to main
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+
+jobs:
+
+  rat:
+    name: Release Audit Tool (RAT)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: 3.8
+      - name: Audit licenses
+        run: ./dev/release/run-rat.sh .

.github/workflows/rust.yml

@@ -19,6 +19,9 @@ name: Rust
 
 on: [push, pull_request]
 
+permissions:
+  contents: read
+
 jobs:
 
   codestyle:
@@ -85,11 +88,8 @@ jobs:
       uses: ./.github/actions/setup-builder
       with:
         rust-version: ${{ matrix.rust }}
+    - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
     - name: Install Tarpaulin
-      uses: actions-rs/install@v0.1
-      with:
-        crate: cargo-tarpaulin
-        version: 0.14.2
-        use-tool-cache: true
+      run: cargo install cargo-tarpaulin
     - name: Test
       run: cargo test --all-features

CHANGELOG.md

@@ -28,6 +28,8 @@ technically be breaking and thus will result in a `0.(N+1)` version.
 
 
 - Unreleased: Check https://github.com/sqlparser-rs/sqlparser-rs/commits/main for undocumented changes.
+- `0.56.0`: [changelog/0.56.0.md](changelog/0.56.0.md)
+- `0.55.0`: [changelog/0.55.0.md](changelog/0.55.0.md)
 - `0.54.0`: [changelog/0.54.0.md](changelog/0.54.0.md)
 - `0.53.0`: [changelog/0.53.0.md](changelog/0.53.0.md)
 - `0.52.0`: [changelog/0.52.0.md](changelog/0.52.0.md)

Cargo.toml

@@ -18,7 +18,7 @@
 [package]
 name = "sqlparser"
 description = "Extensible SQL Lexer and Parser with support for ANSI SQL:2011"
-version = "0.54.0"
+version = "0.57.0"
 authors = ["Apache DataFusion <dev@datafusion.apache.org>"]
 homepage = "https://github.com/apache/datafusion-sqlparser-rs"
 documentation = "https://docs.rs/sqlparser/"
@@ -49,7 +49,7 @@ bigdecimal = { version = "0.4.1", features = ["serde"], optional = true }
 log = "0.4"
 recursive = { version = "0.1.1", optional = true}
 
-serde = { version = "1.0", features = ["derive"], optional = true }
+serde = { version = "1.0", default-features = false, features = ["derive", "alloc"], optional = true }
 # serde_json is only used in examples/cli, but we have to put it outside
 # of dev-dependencies because of
 # https://github.com/rust-lang/cargo/issues/1596

README.md

@@ -53,7 +53,7 @@ println!("AST: {:?}", ast);
 This outputs
 
 ```rust
-AST: [Query(Query { ctes: [], body: Select(Select { distinct: false, projection: [UnnamedExpr(Identifier("a")), UnnamedExpr(Identifier("b")), UnnamedExpr(Value(Long(123))), UnnamedExpr(Function(Function { name: ObjectName(["myfunc"]), args: [Identifier("b")], filter: None, over: None, distinct: false }))], from: [TableWithJoins { relation: Table { name: ObjectName(["table_1"]), alias: None, args: [], with_hints: [] }, joins: [] }], selection: Some(BinaryOp { left: BinaryOp { left: Identifier("a"), op: Gt, right: Identifier("b") }, op: And, right: BinaryOp { left: Identifier("b"), op: Lt, right: Value(Long(100)) } }), group_by: [], having: None }), order_by: [OrderByExpr { expr: Identifier("a"), asc: Some(false) }, OrderByExpr { expr: Identifier("b"), asc: None }], limit: None, offset: None, fetch: None })]
+AST: [Query(Query { ctes: [], body: Select(Select { distinct: false, projection: [UnnamedExpr(Identifier("a")), UnnamedExpr(Identifier("b")), UnnamedExpr(Value(Long(123))), UnnamedExpr(Function(Function { name:ObjectName([Identifier(Ident { value: "myfunc", quote_style: None })]), args: [Identifier("b")], filter: None, over: None, distinct: false }))], from: [TableWithJoins { relation: Table { name: ObjectName([Identifier(Ident { value: "table_1", quote_style: None })]), alias: None, args: [], with_hints: [] }, joins: [] }], selection: Some(BinaryOp { left: BinaryOp { left: Identifier("a"), op: Gt, right: Identifier("b") }, op: And, right: BinaryOp { left: Identifier("b"), op: Lt, right: Value(Long(100)) } }), group_by: [], having: None }), order_by: [OrderByExpr { expr: Identifier("a"), asc: Some(false) }, OrderByExpr { expr: Identifier("b"), asc: None }], limit: None, offset: None, fetch: None })]
 ```
 
 
@@ -89,10 +89,14 @@ keywords, the following should hold true for all SQL:
 
 ```rust
 // Parse SQL
+let sql = "SELECT 'hello'";
 let ast = Parser::parse_sql(&GenericDialect, sql).unwrap();
 
 // The original SQL text can be generated from the AST
 assert_eq!(ast[0].to_string(), sql);
+
+// The SQL can also be pretty-printed with newlines and indentation
+assert_eq!(format!("{:#}", ast[0]), "SELECT\n  'hello'");
 ```
 
 There are still some cases in this crate where different SQL with seemingly
@@ -156,7 +160,8 @@ $ cargo run --features json_example --example cli FILENAME.sql [--dialectname]
 ## Users
 
 This parser is currently being used by the [DataFusion] query engine, [LocustDB],
-[Ballista], [GlueSQL], [Opteryx], [Polars], [PRQL], [Qrlew], [JumpWire], and [ParadeDB].
+[Ballista], [GlueSQL], [Opteryx], [Polars], [PRQL], [Qrlew], [JumpWire], [ParadeDB], [CipherStash Proxy],
+and [GreptimeDB].
 
 If your project is using sqlparser-rs feel free to make a PR to add it
 to this list.
@@ -275,3 +280,5 @@ licensed as above, without any additional terms or conditions.
 [sql-standard]: https://en.wikipedia.org/wiki/ISO/IEC_9075
 [`Dialect`]: https://docs.rs/sqlparser/latest/sqlparser/dialect/trait.Dialect.html
 [`GenericDialect`]: https://docs.rs/sqlparser/latest/sqlparser/dialect/struct.GenericDialect.html
+[CipherStash Proxy]: https://github.com/cipherstash/proxy
+[GreptimeDB]: https://github.com/GreptimeTeam/greptimedb

changelog/0.55.0.md

@@ -0,0 +1,173 @@
+<!--
+Licensed to the Apache Software Foundation (ASF) under one
+or more contributor license agreements.  See the NOTICE file
+distributed with this work for additional information
+regarding copyright ownership.  The ASF licenses this file
+to you under the Apache License, Version 2.0 (the
+"License"); you may not use this file except in compliance
+with the License.  You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied.  See the License for the
+specific language governing permissions and limitations
+under the License.
+-->
+
+# sqlparser-rs 0.55.0 Changelog
+
+This release consists of 55 commits from 25 contributors. See credits at the end of this changelog for more information.
+
+## Migrating usages of `Expr::Value`
+
+In v0.55 of sqlparser the `Expr::Value` enum variant contains a `ValueWithSpan` instead of a `Value`. Here is how to migrate.
+
+### When pattern matching
+
+```diff
+- Expr::Value(Value::SingleQuotedString(my_string)) => { ... }
++ Expr::Value(ValueWithSpan{ value: Value::SingleQuotedString(my_string), span: _ }) => { ... }
+```
+
+### When creating an `Expr`
+
+Use the new `Expr::value` method (notice the lowercase `v`), which will create a `ValueWithSpan` containing an empty span:
+
+```diff
+- Expr::Value(Value::SingleQuotedString(my_string))
++ Expr::value(Value::SingleQuotedString(my_string))
+```
+
+## Migrating usages of `ObjectName`
+
+In v0.55 of sqlparser, the `ObjectName` structure has been changed as shown below. Here is now to migrate.
+
+```diff
+- pub struct ObjectName(pub Vec<Ident>);
++ pub struct ObjectName(pub Vec<ObjectNamePart>)
+```
+
+### When constructing `ObjectName`
+
+Use the `From` impl:
+
+```diff
+- name: ObjectName(vec![Ident::new("f")]),
++ name: ObjectName::from(vec![Ident::new("f")]),
+```
+
+### Accessing Spans
+
+Use the `span()` function
+
+```diff
+- name.span
++ name.span()
+```
+
+
+
+**Breaking changes:**
+
+- Enhance object name path segments [#1539](https://github.com/apache/datafusion-sqlparser-rs/pull/1539) (ayman-sigma)
+- Store spans for Value expressions [#1738](https://github.com/apache/datafusion-sqlparser-rs/pull/1738) (lovasoa)
+
+**Implemented enhancements:**
+
+- feat: adjust create and drop trigger for mysql dialect [#1734](https://github.com/apache/datafusion-sqlparser-rs/pull/1734) (invm)
+
+**Fixed bugs:**
+
+- fix: make `serde` feature no_std [#1730](https://github.com/apache/datafusion-sqlparser-rs/pull/1730) (iajoiner)
+
+**Other:**
+
+- Update rat_exclude_file.txt [#1670](https://github.com/apache/datafusion-sqlparser-rs/pull/1670) (alamb)
+- Add support for Snowflake account privileges [#1666](https://github.com/apache/datafusion-sqlparser-rs/pull/1666) (yoavcloud)
+- Add support for Create Iceberg Table statement for Snowflake parser [#1664](https://github.com/apache/datafusion-sqlparser-rs/pull/1664) (Vedin)
+- National strings: check if dialect supports backslash escape [#1672](https://github.com/apache/datafusion-sqlparser-rs/pull/1672) (hansott)
+- Only support escape literals for Postgres, Redshift and generic dialect [#1674](https://github.com/apache/datafusion-sqlparser-rs/pull/1674) (hansott)
+- BigQuery: Support trailing commas in column definitions list [#1682](https://github.com/apache/datafusion-sqlparser-rs/pull/1682) (iffyio)
+- Enable GROUP BY exp for Snowflake dialect [#1683](https://github.com/apache/datafusion-sqlparser-rs/pull/1683) (yoavcloud)
+- Add support for parsing empty dictionary expressions [#1684](https://github.com/apache/datafusion-sqlparser-rs/pull/1684) (yoavcloud)
+- Support multiple tables in `UPDATE FROM` clause [#1681](https://github.com/apache/datafusion-sqlparser-rs/pull/1681) (iffyio)
+- Add support for mysql table hints [#1675](https://github.com/apache/datafusion-sqlparser-rs/pull/1675) (AvivDavid-Satori)
+- BigQuery: Add support for select expr star [#1680](https://github.com/apache/datafusion-sqlparser-rs/pull/1680) (iffyio)
+- Support underscore separators in numbers for Clickhouse. Fixes #1659 [#1677](https://github.com/apache/datafusion-sqlparser-rs/pull/1677) (graup)
+- BigQuery: Fix column identifier reserved keywords list [#1678](https://github.com/apache/datafusion-sqlparser-rs/pull/1678) (iffyio)
+- Fix bug when parsing a Snowflake stage with `;` suffix [#1688](https://github.com/apache/datafusion-sqlparser-rs/pull/1688) (yoavcloud)
+- Allow plain JOIN without turning it into INNER [#1692](https://github.com/apache/datafusion-sqlparser-rs/pull/1692) (mvzink)
+- Fix DDL generation in case of an empty arguments function. [#1690](https://github.com/apache/datafusion-sqlparser-rs/pull/1690) (remysaissy)
+- Fix `CREATE FUNCTION` round trip for Hive dialect [#1693](https://github.com/apache/datafusion-sqlparser-rs/pull/1693) (iffyio)
+- Make numeric literal underscore test dialect agnostic [#1685](https://github.com/apache/datafusion-sqlparser-rs/pull/1685) (iffyio)
+- Extend lambda support for ClickHouse and DuckDB dialects [#1686](https://github.com/apache/datafusion-sqlparser-rs/pull/1686) (gstvg)
+- Make TypedString preserve quote style [#1679](https://github.com/apache/datafusion-sqlparser-rs/pull/1679) (graup)
+- Do not parse ASOF and MATCH_CONDITION as table factor aliases [#1698](https://github.com/apache/datafusion-sqlparser-rs/pull/1698) (yoavcloud)
+- Add support for GRANT on some common Snowflake objects [#1699](https://github.com/apache/datafusion-sqlparser-rs/pull/1699) (yoavcloud)
+- Add RETURNS TABLE() support for CREATE FUNCTION in Postgresql [#1687](https://github.com/apache/datafusion-sqlparser-rs/pull/1687) (remysaissy)
+- Add parsing for GRANT ROLE and GRANT DATABASE ROLE in Snowflake dialect [#1689](https://github.com/apache/datafusion-sqlparser-rs/pull/1689) (yoavcloud)
+- Add support for `CREATE/ALTER/DROP CONNECTOR` syntax [#1701](https://github.com/apache/datafusion-sqlparser-rs/pull/1701) (wugeer)
+- Parse Snowflake COPY INTO <location> [#1669](https://github.com/apache/datafusion-sqlparser-rs/pull/1669) (yoavcloud)
+- Require space after -- to start single line comment in MySQL [#1705](https://github.com/apache/datafusion-sqlparser-rs/pull/1705) (hansott)
+- Add suppport for Show Objects statement for the Snowflake parser [#1702](https://github.com/apache/datafusion-sqlparser-rs/pull/1702) (DanCodedThis)
+- Fix incorrect parsing of JsonAccess bracket notation after cast in Snowflake [#1708](https://github.com/apache/datafusion-sqlparser-rs/pull/1708) (yoavcloud)
+- Parse Postgres VARBIT datatype [#1703](https://github.com/apache/datafusion-sqlparser-rs/pull/1703) (mvzink)
+- Implement FROM-first selects [#1713](https://github.com/apache/datafusion-sqlparser-rs/pull/1713) (mitsuhiko)
+- Enable custom dialects to support `MATCH() AGAINST()` [#1719](https://github.com/apache/datafusion-sqlparser-rs/pull/1719) (joocer)
+- Support group by cube/rollup etc in BigQuery [#1720](https://github.com/apache/datafusion-sqlparser-rs/pull/1720) (Groennbeck)
+- Add support for MS Varbinary(MAX) (#1714) [#1715](https://github.com/apache/datafusion-sqlparser-rs/pull/1715) (TylerBrinks)
+- Add supports for Hive's `SELECT ... GROUP BY .. GROUPING SETS` syntax [#1653](https://github.com/apache/datafusion-sqlparser-rs/pull/1653) (wugeer)
+- Differentiate LEFT JOIN from LEFT OUTER JOIN [#1726](https://github.com/apache/datafusion-sqlparser-rs/pull/1726) (mvzink)
+- Add support for Postgres `ALTER TYPE` [#1727](https://github.com/apache/datafusion-sqlparser-rs/pull/1727) (jvatic)
+- Replace `Method` and `CompositeAccess` with `CompoundFieldAccess` [#1716](https://github.com/apache/datafusion-sqlparser-rs/pull/1716) (iffyio)
+- Add support for `EXECUTE IMMEDIATE` [#1717](https://github.com/apache/datafusion-sqlparser-rs/pull/1717) (iffyio)
+- Treat COLLATE like any other column option [#1731](https://github.com/apache/datafusion-sqlparser-rs/pull/1731) (mvzink)
+- Add support for PostgreSQL/Redshift geometric operators [#1723](https://github.com/apache/datafusion-sqlparser-rs/pull/1723) (benrsatori)
+- Implement SnowFlake ALTER SESSION [#1712](https://github.com/apache/datafusion-sqlparser-rs/pull/1712) (osipovartem)
+- Extend Visitor trait for Value type [#1725](https://github.com/apache/datafusion-sqlparser-rs/pull/1725) (tomershaniii)
+- Add support for `ORDER BY ALL` [#1724](https://github.com/apache/datafusion-sqlparser-rs/pull/1724) (PokIsemaine)
+- Parse casting to array using double colon operator in Redshift [#1737](https://github.com/apache/datafusion-sqlparser-rs/pull/1737) (yoavcloud)
+- Replace parallel condition/result vectors with single CaseWhen vector in Expr::Case. This fixes the iteration order when using the `Visitor` trait. Expressions are now visited in the same order as they appear in the sql source. [#1733](https://github.com/apache/datafusion-sqlparser-rs/pull/1733) (lovasoa)
+- BigQuery: Add support for `BEGIN` [#1718](https://github.com/apache/datafusion-sqlparser-rs/pull/1718) (iffyio)
+- Parse SIGNED INTEGER type in MySQL CAST [#1739](https://github.com/apache/datafusion-sqlparser-rs/pull/1739) (mvzink)
+- Parse MySQL ALTER TABLE ALGORITHM option [#1745](https://github.com/apache/datafusion-sqlparser-rs/pull/1745) (mvzink)
+- Random test cleanups use Expr::value [#1749](https://github.com/apache/datafusion-sqlparser-rs/pull/1749) (alamb)
+- Parse ALTER TABLE AUTO_INCREMENT operation for MySQL [#1748](https://github.com/apache/datafusion-sqlparser-rs/pull/1748) (mvzink)
+
+## Credits
+
+Thank you to everyone who contributed to this release. Here is a breakdown of commits (PRs merged) per contributor.
+
+```
+    10	Yoav Cohen
+     9	Ifeanyi Ubah
+     7	Michael Victor Zink
+     3	Hans Ott
+     2	Andrew Lamb
+     2	Ophir LOJKINE
+     2	Paul Grau
+     2	Rémy SAISSY
+     2	wugeer
+     1	Armin Ronacher
+     1	Artem Osipov
+     1	AvivDavid-Satori
+     1	Ayman Elkfrawy
+     1	DanCodedThis
+     1	Denys Tsomenko
+     1	Emil
+     1	Ian Alexander Joiner
+     1	Jesse Stuart
+     1	Justin Joyce
+     1	Michael
+     1	SiLe Zhou
+     1	Tyler Brinks
+     1	benrsatori
+     1	gstvg
+     1	tomershaniii
+```
+
+Thank you also to everyone who contributed in other ways such as filing issues, reviewing PRs, and providing feedback on this release.
+

changelog/0.56.0.md

@@ -0,0 +1,102 @@
+<!--
+Licensed to the Apache Software Foundation (ASF) under one
+or more contributor license agreements.  See the NOTICE file
+distributed with this work for additional information
+regarding copyright ownership.  The ASF licenses this file
+to you under the Apache License, Version 2.0 (the
+"License"); you may not use this file except in compliance
+with the License.  You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied.  See the License for the
+specific language governing permissions and limitations
+under the License.
+-->
+
+# sqlparser-rs 0.56.0 Changelog
+
+This release consists of 48 commits from 19 contributors. See credits at the end of this changelog for more information.
+
+**Other:**
+
+- Ignore escaped LIKE wildcards in MySQL [#1735](https://github.com/apache/datafusion-sqlparser-rs/pull/1735) (mvzink)
+- Parse SET NAMES syntax in Postgres [#1752](https://github.com/apache/datafusion-sqlparser-rs/pull/1752) (mvzink)
+- re-add support for nested comments in mssql [#1754](https://github.com/apache/datafusion-sqlparser-rs/pull/1754) (lovasoa)
+- Extend support for INDEX parsing [#1707](https://github.com/apache/datafusion-sqlparser-rs/pull/1707) (LucaCappelletti94)
+- Parse MySQL `ALTER TABLE DROP FOREIGN KEY` syntax [#1762](https://github.com/apache/datafusion-sqlparser-rs/pull/1762) (mvzink)
+- add support for `with` clauses (CTEs) in `delete` statements [#1764](https://github.com/apache/datafusion-sqlparser-rs/pull/1764) (lovasoa)
+- SET with a list of comma separated assignments [#1757](https://github.com/apache/datafusion-sqlparser-rs/pull/1757) (MohamedAbdeen21)
+- Preserve MySQL-style `LIMIT <offset>, <limit>` syntax [#1765](https://github.com/apache/datafusion-sqlparser-rs/pull/1765) (mvzink)
+- Add support for `DROP MATERIALIZED VIEW` [#1743](https://github.com/apache/datafusion-sqlparser-rs/pull/1743) (iffyio)
+- Add `CASE` and `IF` statement support [#1741](https://github.com/apache/datafusion-sqlparser-rs/pull/1741) (iffyio)
+- BigQuery: Add support for `CREATE SCHEMA` options [#1742](https://github.com/apache/datafusion-sqlparser-rs/pull/1742) (iffyio)
+- Snowflake: Support dollar quoted comments [#1755](https://github.com/apache/datafusion-sqlparser-rs/pull/1755) 
+- Add LOCK operation for ALTER TABLE [#1768](https://github.com/apache/datafusion-sqlparser-rs/pull/1768) (MohamedAbdeen21)
+- Add support for `RAISE` statement [#1766](https://github.com/apache/datafusion-sqlparser-rs/pull/1766) (iffyio)
+- Add GLOBAL context/modifier to SET statements [#1767](https://github.com/apache/datafusion-sqlparser-rs/pull/1767) (MohamedAbdeen21)
+- Parse `SUBSTR` as alias for `SUBSTRING` [#1769](https://github.com/apache/datafusion-sqlparser-rs/pull/1769) (mvzink)
+- SET statements: scope modifier for multiple assignments [#1772](https://github.com/apache/datafusion-sqlparser-rs/pull/1772) (MohamedAbdeen21)
+- Support qualified column names in `MATCH AGAINST` clause [#1774](https://github.com/apache/datafusion-sqlparser-rs/pull/1774) (tomershaniii)
+- Mysql: Add support for := operator [#1779](https://github.com/apache/datafusion-sqlparser-rs/pull/1779) (barsela1)
+- Add cipherstash-proxy to list of users in README.md [#1782](https://github.com/apache/datafusion-sqlparser-rs/pull/1782) (coderdan)
+- Fix typos [#1785](https://github.com/apache/datafusion-sqlparser-rs/pull/1785) (jayvdb)
+- Add support for Databricks TIMESTAMP_NTZ. [#1781](https://github.com/apache/datafusion-sqlparser-rs/pull/1781) (romanb)
+- Enable double-dot-notation for mssql. [#1787](https://github.com/apache/datafusion-sqlparser-rs/pull/1787) (romanb)
+- Fix: Snowflake ALTER SESSION cannot be followed by other statements. [#1786](https://github.com/apache/datafusion-sqlparser-rs/pull/1786) (romanb)
+- Add GreptimeDB to the "Users" in README [#1788](https://github.com/apache/datafusion-sqlparser-rs/pull/1788) (MichaelScofield)
+- Extend snowflake grant options support [#1794](https://github.com/apache/datafusion-sqlparser-rs/pull/1794) (yoavcloud)
+- Fix clippy lint on rust 1.86 [#1796](https://github.com/apache/datafusion-sqlparser-rs/pull/1796) (iffyio)
+- Allow single quotes in EXTRACT() for Redshift. [#1795](https://github.com/apache/datafusion-sqlparser-rs/pull/1795) (romanb)
+- MSSQL: Add support for functionality `MERGE` output clause [#1790](https://github.com/apache/datafusion-sqlparser-rs/pull/1790) (dilovancelik)
+- Support additional DuckDB integer types such as HUGEINT, UHUGEINT, etc [#1797](https://github.com/apache/datafusion-sqlparser-rs/pull/1797) (alexander-beedie)
+- Add support for MSSQL IF/ELSE statements. [#1791](https://github.com/apache/datafusion-sqlparser-rs/pull/1791) (romanb)
+- Allow literal backslash escapes for string literals in Redshift dialect. [#1801](https://github.com/apache/datafusion-sqlparser-rs/pull/1801) (romanb)
+- Add support for MySQL's STRAIGHT_JOIN join operator. [#1802](https://github.com/apache/datafusion-sqlparser-rs/pull/1802) (romanb)
+- Snowflake COPY INTO target columns, select items and optional alias [#1805](https://github.com/apache/datafusion-sqlparser-rs/pull/1805) (yoavcloud)
+- Fix tokenization of qualified identifiers with numeric prefix. [#1803](https://github.com/apache/datafusion-sqlparser-rs/pull/1803) (romanb)
+- Add support for `INHERITS` option in `CREATE TABLE` statement [#1806](https://github.com/apache/datafusion-sqlparser-rs/pull/1806) (LucaCappelletti94)
+- Add `DROP TRIGGER` support for SQL Server [#1813](https://github.com/apache/datafusion-sqlparser-rs/pull/1813) (aharpervc)
+- Snowflake: support nested join without parentheses [#1799](https://github.com/apache/datafusion-sqlparser-rs/pull/1799) (barsela1)
+- Add support for parenthesized subquery as `IN` predicate [#1793](https://github.com/apache/datafusion-sqlparser-rs/pull/1793) (adamchainz)
+- Fix `STRAIGHT_JOIN` constraint when table alias is absent [#1812](https://github.com/apache/datafusion-sqlparser-rs/pull/1812) (killertux)
+- Add support for `PRINT` statement for SQL Server [#1811](https://github.com/apache/datafusion-sqlparser-rs/pull/1811) (aharpervc)
+- enable `supports_filter_during_aggregation` for Generic dialect [#1815](https://github.com/apache/datafusion-sqlparser-rs/pull/1815) (goldmedal)
+- Add support for `XMLTABLE` [#1817](https://github.com/apache/datafusion-sqlparser-rs/pull/1817) (lovasoa)
+- Add `CREATE FUNCTION` support for SQL Server [#1808](https://github.com/apache/datafusion-sqlparser-rs/pull/1808) (aharpervc)
+- Add `OR ALTER` support for `CREATE VIEW` [#1818](https://github.com/apache/datafusion-sqlparser-rs/pull/1818) (aharpervc)
+- Add `DECLARE ... CURSOR FOR` support for SQL Server [#1821](https://github.com/apache/datafusion-sqlparser-rs/pull/1821) (aharpervc)
+- Handle missing login in changelog generate script [#1823](https://github.com/apache/datafusion-sqlparser-rs/pull/1823) (iffyio)
+- Snowflake: Add support for `CONNECT_BY_ROOT` [#1780](https://github.com/apache/datafusion-sqlparser-rs/pull/1780) (tomershaniii)
+
+## Credits
+
+Thank you to everyone who contributed to this release. Here is a breakdown of commits (PRs merged) per contributor.
+
+```
+     8	Roman Borschel
+     6	Ifeanyi Ubah
+     5	Andrew Harper
+     5	Michael Victor Zink
+     4	Mohamed Abdeen
+     3	Ophir LOJKINE
+     2	Luca Cappelletti
+     2	Yoav Cohen
+     2	bar sela
+     2	tomershaniii
+     1	Adam Johnson
+     1	Aleksei Piianin
+     1	Alexander Beedie
+     1	Bruno Clemente
+     1	Dan Draper
+     1	DilovanCelik
+     1	Jax Liu
+     1	John Vandenberg
+     1	LFC
+```
+
+Thank you also to everyone who contributed in other ways such as filing issues, reviewing PRs, and providing feedback on this release.
+

changelog/0.57.0.md

@@ -0,0 +1,95 @@
+<!--
+Licensed to the Apache Software Foundation (ASF) under one
+or more contributor license agreements.  See the NOTICE file
+distributed with this work for additional information
+regarding copyright ownership.  The ASF licenses this file
+to you under the Apache License, Version 2.0 (the
+"License"); you may not use this file except in compliance
+with the License.  You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied.  See the License for the
+specific language governing permissions and limitations
+under the License.
+-->
+
+# sqlparser-rs 0.57.0 Changelog
+
+This release consists of 39 commits from 19 contributors. See credits at the end of this changelog for more information.
+
+**Implemented enhancements:**
+
+- feat: Hive: support `SORT BY` direction [#1873](https://github.com/apache/datafusion-sqlparser-rs/pull/1873) (chenkovsky)
+
+**Other:**
+
+- Support some of pipe operators [#1759](https://github.com/apache/datafusion-sqlparser-rs/pull/1759) (simonvandel)
+- Added support for `DROP DOMAIN` [#1828](https://github.com/apache/datafusion-sqlparser-rs/pull/1828) (LucaCappelletti94)
+- Improve support for cursors for SQL Server [#1831](https://github.com/apache/datafusion-sqlparser-rs/pull/1831) (aharpervc)
+- Add all missing table options to be handled in any order [#1747](https://github.com/apache/datafusion-sqlparser-rs/pull/1747) (benrsatori)
+- Add `CREATE TRIGGER` support for SQL Server [#1810](https://github.com/apache/datafusion-sqlparser-rs/pull/1810) (aharpervc)
+- Added support for `CREATE DOMAIN` [#1830](https://github.com/apache/datafusion-sqlparser-rs/pull/1830) (LucaCappelletti94)
+- Allow stored procedures to be defined without `BEGIN`/`END` [#1834](https://github.com/apache/datafusion-sqlparser-rs/pull/1834) (aharpervc)
+- Add support for the MATCH and REGEXP binary operators [#1840](https://github.com/apache/datafusion-sqlparser-rs/pull/1840) (lovasoa)
+- Fix: parsing ident starting with underscore in certain dialects [#1835](https://github.com/apache/datafusion-sqlparser-rs/pull/1835) (MohamedAbdeen21)
+- implement pretty-printing with `{:#}` [#1847](https://github.com/apache/datafusion-sqlparser-rs/pull/1847) (lovasoa)
+- Fix big performance issue in string serialization [#1848](https://github.com/apache/datafusion-sqlparser-rs/pull/1848) (lovasoa)
+- Add support for `DENY` statements [#1836](https://github.com/apache/datafusion-sqlparser-rs/pull/1836) (aharpervc)
+- Postgresql: Add `REPLICA IDENTITY` operation for `ALTER TABLE` [#1844](https://github.com/apache/datafusion-sqlparser-rs/pull/1844) (MohamedAbdeen21)
+- Add support for INCLUDE/EXCLUDE NULLS for UNPIVOT [#1849](https://github.com/apache/datafusion-sqlparser-rs/pull/1849) (Vedin)
+- pretty print improvements [#1851](https://github.com/apache/datafusion-sqlparser-rs/pull/1851) (lovasoa)
+- fix new rust 1.87 cargo clippy warnings [#1856](https://github.com/apache/datafusion-sqlparser-rs/pull/1856) (lovasoa)
+- Update criterion requirement from 0.5 to 0.6 in /sqlparser_bench [#1857](https://github.com/apache/datafusion-sqlparser-rs/pull/1857) (dependabot[bot])
+- pretty-print CREATE TABLE statements [#1854](https://github.com/apache/datafusion-sqlparser-rs/pull/1854) (lovasoa)
+- pretty-print CREATE VIEW statements [#1855](https://github.com/apache/datafusion-sqlparser-rs/pull/1855) (lovasoa)
+- Handle optional datatypes properly in `CREATE FUNCTION` statements [#1826](https://github.com/apache/datafusion-sqlparser-rs/pull/1826) (LucaCappelletti94)
+- Mysql: Add `SRID` column option [#1852](https://github.com/apache/datafusion-sqlparser-rs/pull/1852) (MohamedAbdeen21)
+- Add support for table valued functions for SQL Server [#1839](https://github.com/apache/datafusion-sqlparser-rs/pull/1839) (aharpervc)
+- Keep the COLUMN keyword only if it exists when dropping the column [#1862](https://github.com/apache/datafusion-sqlparser-rs/pull/1862) (git-hulk)
+- Add support for parameter default values in SQL Server [#1866](https://github.com/apache/datafusion-sqlparser-rs/pull/1866) (aharpervc)
+- Add support for `TABLESAMPLE` pipe operator [#1860](https://github.com/apache/datafusion-sqlparser-rs/pull/1860) (hendrikmakait)
+- Adds support for mysql's drop index [#1864](https://github.com/apache/datafusion-sqlparser-rs/pull/1864) (dmzmk)
+- Fix: GROUPING SETS accept values without parenthesis [#1867](https://github.com/apache/datafusion-sqlparser-rs/pull/1867) (Vedin)
+- Add ICEBERG keyword support to ALTER TABLE statement [#1869](https://github.com/apache/datafusion-sqlparser-rs/pull/1869) (osipovartem)
+- MySQL: Support `index_name` in FK constraints [#1871](https://github.com/apache/datafusion-sqlparser-rs/pull/1871) (MohamedAbdeen21)
+- Postgres: Apply `ONLY` keyword per table in TRUNCATE stmt [#1872](https://github.com/apache/datafusion-sqlparser-rs/pull/1872) (MohamedAbdeen21)
+- Fix `CASE` expression spans [#1874](https://github.com/apache/datafusion-sqlparser-rs/pull/1874) (eliaperantoni)
+- MySQL: `[[NOT] ENFORCED]` in CHECK constraint [#1870](https://github.com/apache/datafusion-sqlparser-rs/pull/1870) (MohamedAbdeen21)
+- Add support for `CREATE SCHEMA WITH ( <properties> )` [#1877](https://github.com/apache/datafusion-sqlparser-rs/pull/1877) (utay)
+- Add support for `ALTER TABLE DROP INDEX` [#1865](https://github.com/apache/datafusion-sqlparser-rs/pull/1865) (vimko)
+- chore: Replace archived actions-rs/install action  [#1876](https://github.com/apache/datafusion-sqlparser-rs/pull/1876) (assignUser)
+- Allow `IF NOT EXISTS` after table name for Snowflake [#1881](https://github.com/apache/datafusion-sqlparser-rs/pull/1881) (bombsimon)
+- Support `DISTINCT AS { STRUCT | VALUE }` for BigQuery [#1880](https://github.com/apache/datafusion-sqlparser-rs/pull/1880) (bombsimon)
+
+## Credits
+
+Thank you to everyone who contributed to this release. Here is a breakdown of commits (PRs merged) per contributor.
+
+```
+     7	Ophir LOJKINE
+     6	Andrew Harper
+     6	Mohamed Abdeen
+     3	Luca Cappelletti
+     2	Denys Tsomenko
+     2	Simon Sawert
+     1	Andrew Lamb
+     1	Artem Osipov
+     1	Chen Chongchen
+     1	Dmitriy Mazurin
+     1	Elia Perantoni
+     1	Hendrik Makait
+     1	Jacob Wujciak-Jens
+     1	Simon Vandel Sillesen
+     1	Yannick Utard
+     1	benrsatori
+     1	dependabot[bot]
+     1	hulk
+     1	vimko
+```
+
+Thank you also to everyone who contributed in other ways such as filing issues, reviewing PRs, and providing feedback on this release.
+

dev/release/generate-changelog.py

@@ -28,7 +28,8 @@ def print_pulls(repo_name, title, pulls):
         print()
         for (pull, commit) in pulls:
             url = "https://github.com/{}/pull/{}".format(repo_name, pull.number)
-            print("- {} [#{}]({}) ({})".format(pull.title, pull.number, url, commit.author.login))
+            author = f"({commit.author.login})" if commit.author else ''
+            print("- {} [#{}]({}) {}".format(pull.title, pull.number, url, author))
         print()
 
 
@@ -161,4 +162,4 @@ def cli(args=None):
     generate_changelog(repo, project, args.tag1, args.tag2, args.version)
 
 if __name__ == "__main__":
-    cli()
+    cli()

dev/release/rat_exclude_files.txt

@@ -1,7 +1,8 @@
-# Files to exclude from the Apache Rat (license) check
-.gitignore
 .tool-versions
+target/*
+**.gitignore
+rat.txt
 dev/release/rat_exclude_files.txt
-fuzz/.gitignore
 sqlparser_bench/img/flamegraph.svg
-
+**Cargo.lock
+filtered_rat.txt

examples/cli.rs

@@ -63,7 +63,7 @@ $ cargo run --example cli - [--dialectname]
     };
 
     let contents = if filename == "-" {
-        println!("Parsing from stdin using {:?}", dialect);
+        println!("Parsing from stdin using {dialect:?}");
         let mut buf = Vec::new();
         stdin()
             .read_to_end(&mut buf)

sqlparser_bench/Cargo.toml

@@ -26,7 +26,7 @@ edition = "2018"
 sqlparser = { path = "../" }
 
 [dev-dependencies]
-criterion = "0.5"
+criterion = "0.6"
 
 [[bench]]
 name = "sqlparser_bench"

sqlparser_bench/benches/sqlparser_bench.rs

@@ -45,30 +45,29 @@ fn basic_queries(c: &mut Criterion) {
 
     let large_statement = {
         let expressions = (0..1000)
-            .map(|n| format!("FN_{}(COL_{})", n, n))
+            .map(|n| format!("FN_{n}(COL_{n})"))
             .collect::<Vec<_>>()
             .join(", ");
         let tables = (0..1000)
-            .map(|n| format!("TABLE_{}", n))
+            .map(|n| format!("TABLE_{n}"))
             .collect::<Vec<_>>()
             .join(" JOIN ");
         let where_condition = (0..1000)
-            .map(|n| format!("COL_{} = {}", n, n))
+            .map(|n| format!("COL_{n} = {n}"))
             .collect::<Vec<_>>()
             .join(" OR ");
         let order_condition = (0..1000)
-            .map(|n| format!("COL_{} DESC", n))
+            .map(|n| format!("COL_{n} DESC"))
             .collect::<Vec<_>>()
             .join(", ");
 
         format!(
-            "SELECT {} FROM {} WHERE {} ORDER BY {}",
-            expressions, tables, where_condition, order_condition
+            "SELECT {expressions} FROM {tables} WHERE {where_condition} ORDER BY {order_condition}"
         )
     };
 
     group.bench_function("parse_large_statement", |b| {
-        b.iter(|| Parser::parse_sql(&dialect, criterion::black_box(large_statement.as_str())));
+        b.iter(|| Parser::parse_sql(&dialect, std::hint::black_box(large_statement.as_str())));
     });
 
     let large_statement = Parser::parse_sql(&dialect, large_statement.as_str())

src/ast/data_type.rs

@@ -36,7 +36,7 @@ pub enum EnumMember {
     Name(String),
     /// ClickHouse allows to specify an integer value for each enum value.
     ///
-    /// [clickhouse](https://clickhouse.com/docs/en/sql-reference/data-types/enum)
+    /// [ClickHouse](https://clickhouse.com/docs/en/sql-reference/data-types/enum)
     NamedValue(String, Expr),
 }
 
@@ -45,268 +45,327 @@ pub enum EnumMember {
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
 pub enum DataType {
-    /// Fixed-length character type e.g. CHARACTER(10)
+    /// Table type in [PostgreSQL], e.g. CREATE FUNCTION RETURNS TABLE(...).
+    ///
+    /// [PostgreSQL]: https://www.postgresql.org/docs/15/sql-createfunction.html
+    /// [MsSQL]: https://learn.microsoft.com/en-us/sql/t-sql/statements/create-function-transact-sql?view=sql-server-ver16#c-create-a-multi-statement-table-valued-function
+    Table(Option<Vec<ColumnDef>>),
+    /// Table type with a name, e.g. CREATE FUNCTION RETURNS @result TABLE(...).
+    ///
+    /// [MsSQl]: https://learn.microsoft.com/en-us/sql/t-sql/statements/create-function-transact-sql?view=sql-server-ver16#table
+    NamedTable {
+        /// Table name.
+        name: ObjectName,
+        /// Table columns.
+        columns: Vec<ColumnDef>,
+    },
+    /// Fixed-length character type, e.g. CHARACTER(10).
     Character(Option<CharacterLength>),
-    /// Fixed-length char type e.g. CHAR(10)
+    /// Fixed-length char type, e.g. CHAR(10).
     Char(Option<CharacterLength>),
-    /// Character varying type e.g. CHARACTER VARYING(10)
+    /// Character varying type, e.g. CHARACTER VARYING(10).
     CharacterVarying(Option<CharacterLength>),
-    /// Char varying type e.g. CHAR VARYING(10)
+    /// Char varying type, e.g. CHAR VARYING(10).
     CharVarying(Option<CharacterLength>),
-    /// Variable-length character type e.g. VARCHAR(10)
+    /// Variable-length character type, e.g. VARCHAR(10).
     Varchar(Option<CharacterLength>),
-    /// Variable-length character type e.g. NVARCHAR(10)
+    /// Variable-length character type, e.g. NVARCHAR(10).
     Nvarchar(Option<CharacterLength>),
-    /// Uuid type
+    /// Uuid type.
     Uuid,
-    /// Large character object with optional length e.g. CHARACTER LARGE OBJECT, CHARACTER LARGE OBJECT(1000), [standard]
+    /// Large character object with optional length,
+    /// e.g. CHARACTER LARGE OBJECT, CHARACTER LARGE OBJECT(1000), [SQL Standard].
     ///
-    /// [standard]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#character-large-object-type
+    /// [SQL Standard]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#character-large-object-type
     CharacterLargeObject(Option<u64>),
-    /// Large character object with optional length e.g. CHAR LARGE OBJECT, CHAR LARGE OBJECT(1000), [standard]
+    /// Large character object with optional length,
+    /// e.g. CHAR LARGE OBJECT, CHAR LARGE OBJECT(1000), [SQL Standard].
     ///
-    /// [standard]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#character-large-object-type
+    /// [SQL Standard]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#character-large-object-type
     CharLargeObject(Option<u64>),
-    /// Large character object with optional length e.g. CLOB, CLOB(1000), [standard]
+    /// Large character object with optional length,
+    /// e.g. CLOB, CLOB(1000), [SQL Standard].
     ///
-    /// [standard]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#character-large-object-type
+    /// [SQL Standard]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#character-large-object-type
     /// [Oracle]: https://docs.oracle.com/javadb/10.10.1.2/ref/rrefclob.html
     Clob(Option<u64>),
-    /// Fixed-length binary type with optional length e.g.  [standard], [MS SQL Server]
+    /// Fixed-length binary type with optional length,
+    /// see [SQL Standard], [MS SQL Server].
     ///
-    /// [standard]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#binary-string-type
+    /// [SQL Standard]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#binary-string-type
     /// [MS SQL Server]: https://learn.microsoft.com/pt-br/sql/t-sql/data-types/binary-and-varbinary-transact-sql?view=sql-server-ver16
     Binary(Option<u64>),
-    /// Variable-length binary with optional length type e.g. [standard], [MS SQL Server]
+    /// Variable-length binary with optional length type,
+    /// see [SQL Standard], [MS SQL Server].
     ///
-    /// [standard]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#binary-string-type
+    /// [SQL Standard]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#binary-string-type
     /// [MS SQL Server]: https://learn.microsoft.com/pt-br/sql/t-sql/data-types/binary-and-varbinary-transact-sql?view=sql-server-ver16
-    Varbinary(Option<u64>),
-    /// Large binary object with optional length e.g. BLOB, BLOB(1000), [standard], [Oracle]
+    Varbinary(Option<BinaryLength>),
+    /// Large binary object with optional length,
+    /// see [SQL Standard], [Oracle].
     ///
-    /// [standard]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#binary-large-object-string-type
+    /// [SQL Standard]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#binary-large-object-string-type
     /// [Oracle]: https://docs.oracle.com/javadb/10.8.3.0/ref/rrefblob.html
     Blob(Option<u64>),
-    /// [MySQL] blob with up to 2**8 bytes
+    /// [MySQL] blob with up to 2**8 bytes.
     ///
     /// [MySQL]: https://dev.mysql.com/doc/refman/9.1/en/blob.html
     TinyBlob,
-    /// [MySQL] blob with up to 2**24 bytes
+    /// [MySQL] blob with up to 2**24 bytes.
     ///
     /// [MySQL]: https://dev.mysql.com/doc/refman/9.1/en/blob.html
     MediumBlob,
-    /// [MySQL] blob with up to 2**32 bytes
+    /// [MySQL] blob with up to 2**32 bytes.
     ///
     /// [MySQL]: https://dev.mysql.com/doc/refman/9.1/en/blob.html
     LongBlob,
     /// Variable-length binary data with optional length.
     ///
-    /// [bigquery]: https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types#bytes_type
+    /// [BigQuery]: https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types#bytes_type
     Bytes(Option<u64>),
-    /// Numeric type with optional precision and scale e.g. NUMERIC(10,2), [standard][1]
+    /// Numeric type with optional precision and scale, e.g. NUMERIC(10,2), [SQL Standard][1].
     ///
     /// [1]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#exact-numeric-type
     Numeric(ExactNumberInfo),
-    /// Decimal type with optional precision and scale e.g. DECIMAL(10,2), [standard][1]
+    /// Decimal type with optional precision and scale, e.g. DECIMAL(10,2), [SQL Standard][1].
     ///
     /// [1]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#exact-numeric-type
     Decimal(ExactNumberInfo),
-    /// [BigNumeric] type used in BigQuery
+    /// [BigNumeric] type used in BigQuery.
     ///
     /// [BigNumeric]: https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#bignumeric_literals
     BigNumeric(ExactNumberInfo),
-    /// This is alias for `BigNumeric` type used in BigQuery
+    /// This is alias for `BigNumeric` type used in BigQuery.
     ///
     /// [BigDecimal]: https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types#decimal_types
     BigDecimal(ExactNumberInfo),
-    /// Dec type with optional precision and scale e.g. DEC(10,2), [standard][1]
+    /// Dec type with optional precision and scale, e.g. DEC(10,2), [SQL Standard][1].
     ///
     /// [1]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#exact-numeric-type
     Dec(ExactNumberInfo),
-    /// Floating point with optional precision e.g. FLOAT(8)
+    /// Floating point with optional precision, e.g. FLOAT(8).
     Float(Option<u64>),
-    /// Tiny integer with optional display width e.g. TINYINT or TINYINT(3)
+    /// Tiny integer with optional display width, e.g. TINYINT or TINYINT(3).
     TinyInt(Option<u64>),
-    /// Unsigned tiny integer with optional display width e.g. TINYINT UNSIGNED or TINYINT(3) UNSIGNED
-    UnsignedTinyInt(Option<u64>),
-    /// Int2 as alias for SmallInt in [postgresql]
-    /// Note: Int2 mean 2 bytes in postgres (not 2 bits)
-    /// Int2 with optional display width e.g. INT2 or INT2(5)
+    /// Unsigned tiny integer with optional display width,
+    /// e.g. TINYINT UNSIGNED or TINYINT(3) UNSIGNED.
+    TinyIntUnsigned(Option<u64>),
+    /// Unsigned tiny integer, e.g. UTINYINT
+    UTinyInt,
+    /// Int2 is an alias for SmallInt in [PostgreSQL].
+    /// Note: Int2 means 2 bytes in PostgreSQL (not 2 bits).
+    /// Int2 with optional display width, e.g. INT2 or INT2(5).
     ///
-    /// [postgresql]: https://www.postgresql.org/docs/15/datatype.html
+    /// [PostgreSQL]: https://www.postgresql.org/docs/current/datatype.html
     Int2(Option<u64>),
-    /// Unsigned Int2 with optional display width e.g. INT2 Unsigned or INT2(5) Unsigned
-    UnsignedInt2(Option<u64>),
-    /// Small integer with optional display width e.g. SMALLINT or SMALLINT(5)
+    /// Unsigned Int2 with optional display width, e.g. INT2 UNSIGNED or INT2(5) UNSIGNED.
+    Int2Unsigned(Option<u64>),
+    /// Small integer with optional display width, e.g. SMALLINT or SMALLINT(5).
     SmallInt(Option<u64>),
-    /// Unsigned small integer with optional display width e.g. SMALLINT UNSIGNED or SMALLINT(5) UNSIGNED
-    UnsignedSmallInt(Option<u64>),
-    /// MySQL medium integer ([1]) with optional display width e.g. MEDIUMINT or MEDIUMINT(5)
+    /// Unsigned small integer with optional display width,
+    /// e.g. SMALLINT UNSIGNED or SMALLINT(5) UNSIGNED.
+    SmallIntUnsigned(Option<u64>),
+    /// Unsigned small integer, e.g. USMALLINT.
+    USmallInt,
+    /// MySQL medium integer ([1]) with optional display width,
+    /// e.g. MEDIUMINT or MEDIUMINT(5).
     ///
     /// [1]: https://dev.mysql.com/doc/refman/8.0/en/integer-types.html
     MediumInt(Option<u64>),
-    /// Unsigned medium integer ([1]) with optional display width e.g. MEDIUMINT UNSIGNED or MEDIUMINT(5) UNSIGNED
+    /// Unsigned medium integer ([1]) with optional display width,
+    /// e.g. MEDIUMINT UNSIGNED or MEDIUMINT(5) UNSIGNED.
     ///
     /// [1]: https://dev.mysql.com/doc/refman/8.0/en/integer-types.html
-    UnsignedMediumInt(Option<u64>),
-    /// Int with optional display width e.g. INT or INT(11)
+    MediumIntUnsigned(Option<u64>),
+    /// Int with optional display width, e.g. INT or INT(11).
     Int(Option<u64>),
-    /// Int4 as alias for Integer in [postgresql]
-    /// Note: Int4 mean 4 bytes in postgres (not 4 bits)
-    /// Int4 with optional display width e.g. Int4 or Int4(11)
+    /// Int4 is an alias for Integer in [PostgreSQL].
+    /// Note: Int4 means 4 bytes in PostgreSQL (not 4 bits).
+    /// Int4 with optional display width, e.g. Int4 or Int4(11).
     ///
-    /// [postgresql]: https://www.postgresql.org/docs/15/datatype.html
+    /// [PostgreSQL]: https://www.postgresql.org/docs/current/datatype.html
     Int4(Option<u64>),
-    /// Int8 as alias for Bigint in [postgresql] and integer type in [clickhouse]
-    /// Note: Int8 mean 8 bytes in [postgresql] (not 8 bits)
-    /// Int8 with optional display width e.g. INT8 or INT8(11)
-    /// Note: Int8 mean 8 bits in [clickhouse]
+    /// Int8 is an alias for BigInt in [PostgreSQL] and Integer type in [ClickHouse].
+    /// Int8 with optional display width, e.g. INT8 or INT8(11).
+    /// Note: Int8 means 8 bytes in [PostgreSQL], but 8 bits in [ClickHouse].
     ///
-    /// [postgresql]: https://www.postgresql.org/docs/15/datatype.html
-    /// [clickhouse]: https://clickhouse.com/docs/en/sql-reference/data-types/int-uint
+    /// [PostgreSQL]: https://www.postgresql.org/docs/current/datatype.html
+    /// [ClickHouse]: https://clickhouse.com/docs/en/sql-reference/data-types/int-uint
     Int8(Option<u64>),
-    /// Integer type in [clickhouse]
-    /// Note: Int16 mean 16 bits in [clickhouse]
+    /// Integer type in [ClickHouse].
+    /// Note: Int16 means 16 bits in [ClickHouse].
     ///
-    /// [clickhouse]: https://clickhouse.com/docs/en/sql-reference/data-types/int-uint
+    /// [ClickHouse]: https://clickhouse.com/docs/en/sql-reference/data-types/int-uint
     Int16,
-    /// Integer type in [clickhouse]
-    /// Note: Int16 mean 32 bits in [clickhouse]
+    /// Integer type in [ClickHouse].
+    /// Note: Int32 means 32 bits in [ClickHouse].
     ///
-    /// [clickhouse]: https://clickhouse.com/docs/en/sql-reference/data-types/int-uint
+    /// [ClickHouse]: https://clickhouse.com/docs/en/sql-reference/data-types/int-uint
     Int32,
-    /// Integer type in [bigquery], [clickhouse]
+    /// Integer type in [BigQuery], [ClickHouse].
     ///
-    /// [bigquery]: https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types#integer_types
-    /// [clickhouse]: https://clickhouse.com/docs/en/sql-reference/data-types/int-uint
+    /// [BigQuery]: https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types#integer_types
+    /// [ClickHouse]: https://clickhouse.com/docs/en/sql-reference/data-types/int-uint
     Int64,
-    /// Integer type in [clickhouse]
-    /// Note: Int128 mean 128 bits in [clickhouse]
+    /// Integer type in [ClickHouse].
+    /// Note: Int128 means 128 bits in [ClickHouse].
     ///
-    /// [clickhouse]: https://clickhouse.com/docs/en/sql-reference/data-types/int-uint
+    /// [ClickHouse]: https://clickhouse.com/docs/en/sql-reference/data-types/int-uint
     Int128,
-    /// Integer type in [clickhouse]
-    /// Note: Int256 mean 256 bits in [clickhouse]
+    /// Integer type in [ClickHouse].
+    /// Note: Int256 means 256 bits in [ClickHouse].
     ///
-    /// [clickhouse]: https://clickhouse.com/docs/en/sql-reference/data-types/int-uint
+    /// [ClickHouse]: https://clickhouse.com/docs/en/sql-reference/data-types/int-uint
     Int256,
-    /// Integer with optional display width e.g. INTEGER or INTEGER(11)
+    /// Integer with optional display width, e.g. INTEGER or INTEGER(11).
     Integer(Option<u64>),
-    /// Unsigned int with optional display width e.g. INT UNSIGNED or INT(11) UNSIGNED
-    UnsignedInt(Option<u64>),
-    /// Unsigned int4 with optional display width e.g. INT4 UNSIGNED or INT4(11) UNSIGNED
-    UnsignedInt4(Option<u64>),
-    /// Unsigned integer with optional display width e.g. INTEGER UNSIGNED or INTEGER(11) UNSIGNED
-    UnsignedInteger(Option<u64>),
-    /// Unsigned integer type in [clickhouse]
-    /// Note: UInt8 mean 8 bits in [clickhouse]
+    /// Unsigned int with optional display width, e.g. INT UNSIGNED or INT(11) UNSIGNED.
+    IntUnsigned(Option<u64>),
+    /// Unsigned int4 with optional display width, e.g. INT4 UNSIGNED or INT4(11) UNSIGNED.
+    Int4Unsigned(Option<u64>),
+    /// Unsigned integer with optional display width, e.g. INTEGER UNSIGNED or INTEGER(11) UNSIGNED.
+    IntegerUnsigned(Option<u64>),
+    /// 128-bit integer type, e.g. HUGEINT.
+    HugeInt,
+    /// Unsigned 128-bit integer type, e.g. UHUGEINT.
+    UHugeInt,
+    /// Unsigned integer type in [ClickHouse].
+    /// Note: UInt8 means 8 bits in [ClickHouse].
     ///
-    /// [clickhouse]: https://clickhouse.com/docs/en/sql-reference/data-types/int-uint
+    /// [ClickHouse]: https://clickhouse.com/docs/en/sql-reference/data-types/int-uint
     UInt8,
-    /// Unsigned integer type in [clickhouse]
-    /// Note: UInt16 mean 16 bits in [clickhouse]
+    /// Unsigned integer type in [ClickHouse].
+    /// Note: UInt16 means 16 bits in [ClickHouse].
     ///
-    /// [clickhouse]: https://clickhouse.com/docs/en/sql-reference/data-types/int-uint
+    /// [ClickHouse]: https://clickhouse.com/docs/en/sql-reference/data-types/int-uint
     UInt16,
-    /// Unsigned integer type in [clickhouse]
-    /// Note: UInt32 mean 32 bits in [clickhouse]
+    /// Unsigned integer type in [ClickHouse].
+    /// Note: UInt32 means 32 bits in [ClickHouse].
     ///
-    /// [clickhouse]: https://clickhouse.com/docs/en/sql-reference/data-types/int-uint
+    /// [ClickHouse]: https://clickhouse.com/docs/en/sql-reference/data-types/int-uint
     UInt32,
-    /// Unsigned integer type in [clickhouse]
-    /// Note: UInt64 mean 64 bits in [clickhouse]
+    /// Unsigned integer type in [ClickHouse].
+    /// Note: UInt64 means 64 bits in [ClickHouse].
     ///
-    /// [clickhouse]: https://clickhouse.com/docs/en/sql-reference/data-types/int-uint
+    /// [ClickHouse]: https://clickhouse.com/docs/en/sql-reference/data-types/int-uint
     UInt64,
-    /// Unsigned integer type in [clickhouse]
-    /// Note: UInt128 mean 128 bits in [clickhouse]
+    /// Unsigned integer type in [ClickHouse].
+    /// Note: UInt128 means 128 bits in [ClickHouse].
     ///
-    /// [clickhouse]: https://clickhouse.com/docs/en/sql-reference/data-types/int-uint
+    /// [ClickHouse]: https://clickhouse.com/docs/en/sql-reference/data-types/int-uint
     UInt128,
-    /// Unsigned integer type in [clickhouse]
-    /// Note: UInt256 mean 256 bits in [clickhouse]
+    /// Unsigned integer type in [ClickHouse].
+    /// Note: UInt256 means 256 bits in [ClickHouse].
     ///
-    /// [clickhouse]: https://clickhouse.com/docs/en/sql-reference/data-types/int-uint
+    /// [ClickHouse]: https://clickhouse.com/docs/en/sql-reference/data-types/int-uint
     UInt256,
-    /// Big integer with optional display width e.g. BIGINT or BIGINT(20)
+    /// Big integer with optional display width, e.g. BIGINT or BIGINT(20).
     BigInt(Option<u64>),
-    /// Unsigned big integer with optional display width e.g. BIGINT UNSIGNED or BIGINT(20) UNSIGNED
-    UnsignedBigInt(Option<u64>),
-    /// Unsigned Int8 with optional display width e.g. INT8 UNSIGNED or INT8(11) UNSIGNED
-    UnsignedInt8(Option<u64>),
-    /// Float4 as alias for Real in [postgresql]
+    /// Unsigned big integer with optional display width, e.g. BIGINT UNSIGNED or BIGINT(20) UNSIGNED.
+    BigIntUnsigned(Option<u64>),
+    /// Unsigned big integer, e.g. UBIGINT.
+    UBigInt,
+    /// Unsigned Int8 with optional display width, e.g. INT8 UNSIGNED or INT8(11) UNSIGNED.
+    Int8Unsigned(Option<u64>),
+    /// Signed integer as used in [MySQL CAST] target types, without optional `INTEGER` suffix,
+    /// e.g. `SIGNED`
     ///
-    /// [postgresql]: https://www.postgresql.org/docs/15/datatype.html
+    /// [MySQL CAST]: https://dev.mysql.com/doc/refman/8.4/en/cast-functions.html
+    Signed,
+    /// Signed integer as used in [MySQL CAST] target types, with optional `INTEGER` suffix,
+    /// e.g. `SIGNED INTEGER`
+    ///
+    /// [MySQL CAST]: https://dev.mysql.com/doc/refman/8.4/en/cast-functions.html
+    SignedInteger,
+    /// Signed integer as used in [MySQL CAST] target types, without optional `INTEGER` suffix,
+    /// e.g. `SIGNED`
+    ///
+    /// [MySQL CAST]: https://dev.mysql.com/doc/refman/8.4/en/cast-functions.html
+    Unsigned,
+    /// Unsigned integer as used in [MySQL CAST] target types, with optional `INTEGER` suffix,
+    /// e.g. `UNSIGNED INTEGER`.
+    ///
+    /// [MySQL CAST]: https://dev.mysql.com/doc/refman/8.4/en/cast-functions.html
+    UnsignedInteger,
+    /// Float4 is an alias for Real in [PostgreSQL].
+    ///
+    /// [PostgreSQL]: https://www.postgresql.org/docs/current/datatype.html
     Float4,
-    /// Floating point in [clickhouse]
+    /// Floating point in [ClickHouse].
     ///
-    /// [clickhouse]: https://clickhouse.com/docs/en/sql-reference/data-types/float
+    /// [ClickHouse]: https://clickhouse.com/docs/en/sql-reference/data-types/float
     Float32,
-    /// Floating point in [bigquery]
+    /// Floating point in [BigQuery].
     ///
-    /// [bigquery]: https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types#floating_point_types
-    /// [clickhouse]: https://clickhouse.com/docs/en/sql-reference/data-types/float
+    /// [BigQuery]: https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types#floating_point_types
+    /// [ClickHouse]: https://clickhouse.com/docs/en/sql-reference/data-types/float
     Float64,
-    /// Floating point e.g. REAL
+    /// Floating point, e.g. REAL.
     Real,
-    /// Float8 as alias for Double in [postgresql]
+    /// Float8 is an alias for Double in [PostgreSQL].
     ///
-    /// [postgresql]: https://www.postgresql.org/docs/15/datatype.html
+    /// [PostgreSQL]: https://www.postgresql.org/docs/current/datatype.html
     Float8,
     /// Double
     Double(ExactNumberInfo),
-    /// Double PRECISION e.g. [standard], [postgresql]
+    /// Double Precision, see [SQL Standard], [PostgreSQL].
     ///
-    /// [standard]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#approximate-numeric-type
-    /// [postgresql]: https://www.postgresql.org/docs/current/datatype-numeric.html
+    /// [SQL Standard]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#approximate-numeric-type
+    /// [PostgreSQL]: https://www.postgresql.org/docs/current/datatype-numeric.html
     DoublePrecision,
-    /// Bool as alias for Boolean in [postgresql]
+    /// Bool is an alias for Boolean, see [PostgreSQL].
     ///
-    /// [postgresql]: https://www.postgresql.org/docs/15/datatype.html
+    /// [PostgreSQL]: https://www.postgresql.org/docs/current/datatype.html
     Bool,
-    /// Boolean
+    /// Boolean type.
     Boolean,
-    /// Date
+    /// Date type.
     Date,
-    /// Date32 with the same range as Datetime64
+    /// Date32 with the same range as Datetime64.
     ///
     /// [1]: https://clickhouse.com/docs/en/sql-reference/data-types/date32
     Date32,
-    /// Time with optional time precision and time zone information e.g. [standard][1].
+    /// Time with optional time precision and time zone information, see [SQL Standard][1].
     ///
     /// [1]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#datetime-type
     Time(Option<u64>, TimezoneInfo),
-    /// Datetime with optional time precision e.g. [MySQL][1].
+    /// Datetime with optional time precision, see [MySQL][1].
     ///
     /// [1]: https://dev.mysql.com/doc/refman/8.0/en/datetime.html
     Datetime(Option<u64>),
-    /// Datetime with time precision and optional timezone e.g. [ClickHouse][1].
+    /// Datetime with time precision and optional timezone, see [ClickHouse][1].
     ///
     /// [1]: https://clickhouse.com/docs/en/sql-reference/data-types/datetime64
     Datetime64(u64, Option<String>),
-    /// Timestamp with optional time precision and time zone information e.g. [standard][1].
+    /// Timestamp with optional time precision and time zone information, see [SQL Standard][1].
     ///
     /// [1]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#datetime-type
     Timestamp(Option<u64>, TimezoneInfo),
-    /// Interval
+    /// Databricks timestamp without time zone. See [1].
+    ///
+    /// [1]: https://docs.databricks.com/aws/en/sql/language-manual/data-types/timestamp-ntz-type
+    TimestampNtz,
+    /// Interval type.
     Interval,
-    /// JSON type
+    /// JSON type.
     JSON,
-    /// Binary JSON type
+    /// Binary JSON type.
     JSONB,
-    /// Regclass used in postgresql serial
+    /// Regclass used in [PostgreSQL] serial.
+    ///
+    /// [PostgreSQL]: https://www.postgresql.org/docs/current/datatype.html
     Regclass,
-    /// Text
+    /// Text type.
     Text,
-    /// [MySQL] text with up to 2**8 bytes
+    /// [MySQL] text with up to 2**8 bytes.
     ///
     /// [MySQL]: https://dev.mysql.com/doc/refman/9.1/en/blob.html
     TinyText,
-    /// [MySQL] text with up to 2**24 bytes
+    /// [MySQL] text with up to 2**24 bytes.
     ///
     /// [MySQL]: https://dev.mysql.com/doc/refman/9.1/en/blob.html
     MediumText,
-    /// [MySQL] text with up to 2**32 bytes
+    /// [MySQL] text with up to 2**32 bytes.
     ///
     /// [MySQL]: https://dev.mysql.com/doc/refman/9.1/en/blob.html
     LongText,
@@ -316,67 +375,85 @@ pub enum DataType {
     ///
     /// [1]: https://clickhouse.com/docs/en/sql-reference/data-types/fixedstring
     FixedString(u64),
-    /// Bytea
-    Bytea,
-    /// Bit string, e.g. [Postgres], [MySQL], or [MSSQL]
+    /// Bytea type, see [PostgreSQL].
     ///
-    /// [Postgres]: https://www.postgresql.org/docs/current/datatype-bit.html
+    /// [PostgreSQL]: https://www.postgresql.org/docs/current/datatype-bit.html
+    Bytea,
+    /// Bit string, see [PostgreSQL], [MySQL], or [MSSQL].
+    ///
+    /// [PostgreSQL]: https://www.postgresql.org/docs/current/datatype-bit.html
     /// [MySQL]: https://dev.mysql.com/doc/refman/9.1/en/bit-type.html
     /// [MSSQL]: https://learn.microsoft.com/en-us/sql/t-sql/data-types/bit-transact-sql?view=sql-server-ver16
     Bit(Option<u64>),
-    /// Variable-length bit string e.g. [Postgres]
+    /// `BIT VARYING(n)`: Variable-length bit string, see [PostgreSQL].
     ///
-    /// [Postgres]: https://www.postgresql.org/docs/current/datatype-bit.html
+    /// [PostgreSQL]: https://www.postgresql.org/docs/current/datatype-bit.html
     BitVarying(Option<u64>),
-    /// Custom type such as enums
+    /// `VARBIT(n)`: Variable-length bit string. [PostgreSQL] alias for `BIT VARYING`.
+    ///
+    /// [PostgreSQL]: https://www.postgresql.org/docs/current/datatype.html
+    VarBit(Option<u64>),
+    /// Custom types.
     Custom(ObjectName, Vec<String>),
-    /// Arrays
+    /// Arrays.
     Array(ArrayElemTypeDef),
-    /// Map
+    /// Map, see [ClickHouse].
     ///
-    /// [clickhouse]: https://clickhouse.com/docs/en/sql-reference/data-types/map
+    /// [ClickHouse]: https://clickhouse.com/docs/en/sql-reference/data-types/map
     Map(Box<DataType>, Box<DataType>),
-    /// Tuple
+    /// Tuple, see [ClickHouse].
     ///
-    /// [clickhouse]: https://clickhouse.com/docs/en/sql-reference/data-types/tuple
+    /// [ClickHouse]: https://clickhouse.com/docs/en/sql-reference/data-types/tuple
     Tuple(Vec<StructField>),
-    /// Nested
+    /// Nested type, see [ClickHouse].
     ///
-    /// [clickhouse]: https://clickhouse.com/docs/en/sql-reference/data-types/nested-data-structures/nested
+    /// [ClickHouse]: https://clickhouse.com/docs/en/sql-reference/data-types/nested-data-structures/nested
     Nested(Vec<ColumnDef>),
-    /// Enums
+    /// Enum type.
     Enum(Vec<EnumMember>, Option<u8>),
-    /// Set
+    /// Set type.
     Set(Vec<String>),
-    /// Struct
+    /// Struct type, see [Hive], [BigQuery].
     ///
-    /// [hive]: https://docs.cloudera.com/cdw-runtime/cloud/impala-sql-reference/topics/impala-struct.html
-    /// [bigquery]: https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types#struct_type
+    /// [Hive]: https://docs.cloudera.com/cdw-runtime/cloud/impala-sql-reference/topics/impala-struct.html
+    /// [BigQuery]: https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types#struct_type
     Struct(Vec<StructField>, StructBracketKind),
-    /// Union
+    /// Union type, see [DuckDB].
     ///
-    /// [duckdb]: https://duckdb.org/docs/sql/data_types/union.html
+    /// [DuckDB]: https://duckdb.org/docs/sql/data_types/union.html
     Union(Vec<UnionField>),
     /// Nullable - special marker NULL represents in ClickHouse as a data type.
     ///
-    /// [clickhouse]: https://clickhouse.com/docs/en/sql-reference/data-types/nullable
+    /// [ClickHouse]: https://clickhouse.com/docs/en/sql-reference/data-types/nullable
     Nullable(Box<DataType>),
     /// LowCardinality - changes the internal representation of other data types to be dictionary-encoded.
     ///
-    /// [clickhouse]: https://clickhouse.com/docs/en/sql-reference/data-types/lowcardinality
+    /// [ClickHouse]: https://clickhouse.com/docs/en/sql-reference/data-types/lowcardinality
     LowCardinality(Box<DataType>),
     /// No type specified - only used with
     /// [`SQLiteDialect`](crate::dialect::SQLiteDialect), from statements such
     /// as `CREATE TABLE t1 (a)`.
     Unspecified,
-    /// Trigger data type, returned by functions associated with triggers
+    /// Trigger data type, returned by functions associated with triggers, see [PostgreSQL].
     ///
-    /// [postgresql]: https://www.postgresql.org/docs/current/plpgsql-trigger.html
+    /// [PostgreSQL]: https://www.postgresql.org/docs/current/plpgsql-trigger.html
     Trigger,
-    /// Any data type, used in BigQuery UDF definitions for templated parameters
+    /// Any data type, used in BigQuery UDF definitions for templated parameters, see [BigQuery].
     ///
-    /// [bigquery]: https://cloud.google.com/bigquery/docs/user-defined-functions#templated-sql-udf-parameters
+    /// [BigQuery]: https://cloud.google.com/bigquery/docs/user-defined-functions#templated-sql-udf-parameters
     AnyType,
+    /// Geometric type, see [PostgreSQL].
+    ///
+    /// [PostgreSQL]: https://www.postgresql.org/docs/9.5/functions-geometry.html
+    GeometricType(GeometricTypeKind),
+    /// PostgreSQL text search vectors, see [PostgreSQL].
+    ///
+    /// [PostgreSQL]: https://www.postgresql.org/docs/17/datatype-textsearch.html
+    TsVector,
+    /// PostgreSQL text search query, see [PostgreSQL].
+    ///
+    /// [PostgreSQL]: https://www.postgresql.org/docs/17/datatype-textsearch.html
+    TsQuery,
 }
 
 impl fmt::Display for DataType {
@@ -399,9 +476,7 @@ impl fmt::Display for DataType {
             }
             DataType::Clob(size) => format_type_with_optional_length(f, "CLOB", size, false),
             DataType::Binary(size) => format_type_with_optional_length(f, "BINARY", size, false),
-            DataType::Varbinary(size) => {
-                format_type_with_optional_length(f, "VARBINARY", size, false)
-            }
+            DataType::Varbinary(size) => format_varbinary_type(f, "VARBINARY", size),
             DataType::Blob(size) => format_type_with_optional_length(f, "BLOB", size, false),
             DataType::TinyBlob => write!(f, "TINYBLOB"),
             DataType::MediumBlob => write!(f, "MEDIUMBLOB"),
@@ -422,29 +497,29 @@ impl fmt::Display for DataType {
             DataType::TinyInt(zerofill) => {
                 format_type_with_optional_length(f, "TINYINT", zerofill, false)
             }
-            DataType::UnsignedTinyInt(zerofill) => {
+            DataType::TinyIntUnsigned(zerofill) => {
                 format_type_with_optional_length(f, "TINYINT", zerofill, true)
             }
             DataType::Int2(zerofill) => {
                 format_type_with_optional_length(f, "INT2", zerofill, false)
             }
-            DataType::UnsignedInt2(zerofill) => {
+            DataType::Int2Unsigned(zerofill) => {
                 format_type_with_optional_length(f, "INT2", zerofill, true)
             }
             DataType::SmallInt(zerofill) => {
                 format_type_with_optional_length(f, "SMALLINT", zerofill, false)
             }
-            DataType::UnsignedSmallInt(zerofill) => {
+            DataType::SmallIntUnsigned(zerofill) => {
                 format_type_with_optional_length(f, "SMALLINT", zerofill, true)
             }
             DataType::MediumInt(zerofill) => {
                 format_type_with_optional_length(f, "MEDIUMINT", zerofill, false)
             }
-            DataType::UnsignedMediumInt(zerofill) => {
+            DataType::MediumIntUnsigned(zerofill) => {
                 format_type_with_optional_length(f, "MEDIUMINT", zerofill, true)
             }
             DataType::Int(zerofill) => format_type_with_optional_length(f, "INT", zerofill, false),
-            DataType::UnsignedInt(zerofill) => {
+            DataType::IntUnsigned(zerofill) => {
                 format_type_with_optional_length(f, "INT", zerofill, true)
             }
             DataType::Int4(zerofill) => {
@@ -468,24 +543,39 @@ impl fmt::Display for DataType {
             DataType::Int256 => {
                 write!(f, "Int256")
             }
-            DataType::UnsignedInt4(zerofill) => {
+            DataType::HugeInt => {
+                write!(f, "HUGEINT")
+            }
+            DataType::Int4Unsigned(zerofill) => {
                 format_type_with_optional_length(f, "INT4", zerofill, true)
             }
             DataType::Integer(zerofill) => {
                 format_type_with_optional_length(f, "INTEGER", zerofill, false)
             }
-            DataType::UnsignedInteger(zerofill) => {
+            DataType::IntegerUnsigned(zerofill) => {
                 format_type_with_optional_length(f, "INTEGER", zerofill, true)
             }
             DataType::BigInt(zerofill) => {
                 format_type_with_optional_length(f, "BIGINT", zerofill, false)
             }
-            DataType::UnsignedBigInt(zerofill) => {
+            DataType::BigIntUnsigned(zerofill) => {
                 format_type_with_optional_length(f, "BIGINT", zerofill, true)
             }
-            DataType::UnsignedInt8(zerofill) => {
+            DataType::Int8Unsigned(zerofill) => {
                 format_type_with_optional_length(f, "INT8", zerofill, true)
             }
+            DataType::UTinyInt => {
+                write!(f, "UTINYINT")
+            }
+            DataType::USmallInt => {
+                write!(f, "USMALLINT")
+            }
+            DataType::UBigInt => {
+                write!(f, "UBIGINT")
+            }
+            DataType::UHugeInt => {
+                write!(f, "UHUGEINT")
+            }
             DataType::UInt8 => {
                 write!(f, "UInt8")
             }
@@ -504,6 +594,18 @@ impl fmt::Display for DataType {
             DataType::UInt256 => {
                 write!(f, "UInt256")
             }
+            DataType::Signed => {
+                write!(f, "SIGNED")
+            }
+            DataType::SignedInteger => {
+                write!(f, "SIGNED INTEGER")
+            }
+            DataType::Unsigned => {
+                write!(f, "UNSIGNED")
+            }
+            DataType::UnsignedInteger => {
+                write!(f, "UNSIGNED INTEGER")
+            }
             DataType::Real => write!(f, "REAL"),
             DataType::Float4 => write!(f, "FLOAT4"),
             DataType::Float32 => write!(f, "Float32"),
@@ -524,6 +626,7 @@ impl fmt::Display for DataType {
             DataType::Timestamp(precision, timezone_info) => {
                 format_datetime_precision_and_tz(f, "TIMESTAMP", precision, timezone_info)
             }
+            DataType::TimestampNtz => write!(f, "TIMESTAMP_NTZ"),
             DataType::Datetime64(precision, timezone) => {
                 format_clickhouse_datetime_precision_and_timezone(
                     f,
@@ -546,6 +649,7 @@ impl fmt::Display for DataType {
             DataType::BitVarying(size) => {
                 format_type_with_optional_length(f, "BIT VARYING", size, false)
             }
+            DataType::VarBit(size) => format_type_with_optional_length(f, "VARBIT", size, false),
             DataType::Array(ty) => match ty {
                 ArrayElemTypeDef::None => write!(f, "ARRAY"),
                 ArrayElemTypeDef::SquareBracket(t, None) => write!(f, "{t}[]"),
@@ -562,7 +666,7 @@ impl fmt::Display for DataType {
             }
             DataType::Enum(vals, bits) => {
                 match bits {
-                    Some(bits) => write!(f, "ENUM{}", bits),
+                    Some(bits) => write!(f, "ENUM{bits}"),
                     None => write!(f, "ENUM"),
                 }?;
                 write!(f, "(")?;
@@ -610,16 +714,16 @@ impl fmt::Display for DataType {
             }
             // ClickHouse
             DataType::Nullable(data_type) => {
-                write!(f, "Nullable({})", data_type)
+                write!(f, "Nullable({data_type})")
             }
             DataType::FixedString(character_length) => {
-                write!(f, "FixedString({})", character_length)
+                write!(f, "FixedString({character_length})")
             }
             DataType::LowCardinality(data_type) => {
-                write!(f, "LowCardinality({})", data_type)
+                write!(f, "LowCardinality({data_type})")
             }
             DataType::Map(key_data_type, value_data_type) => {
-                write!(f, "Map({}, {})", key_data_type, value_data_type)
+                write!(f, "Map({key_data_type}, {value_data_type})")
             }
             DataType::Tuple(fields) => {
                 write!(f, "Tuple({})", display_comma_separated(fields))
@@ -630,6 +734,20 @@ impl fmt::Display for DataType {
             DataType::Unspecified => Ok(()),
             DataType::Trigger => write!(f, "TRIGGER"),
             DataType::AnyType => write!(f, "ANY TYPE"),
+            DataType::Table(fields) => match fields {
+                Some(fields) => {
+                    write!(f, "TABLE({})", display_comma_separated(fields))
+                }
+                None => {
+                    write!(f, "TABLE")
+                }
+            },
+            DataType::NamedTable { name, columns } => {
+                write!(f, "{} TABLE ({})", name, display_comma_separated(columns))
+            }
+            DataType::GeometricType(kind) => write!(f, "{kind}"),
+            DataType::TsVector => write!(f, "TSVECTOR"),
+            DataType::TsQuery => write!(f, "TSQUERY"),
         }
     }
 }
@@ -662,6 +780,18 @@ fn format_character_string_type(
     Ok(())
 }
 
+fn format_varbinary_type(
+    f: &mut fmt::Formatter,
+    sql_type: &str,
+    size: &Option<BinaryLength>,
+) -> fmt::Result {
+    write!(f, "{sql_type}")?;
+    if let Some(size) = size {
+        write!(f, "({size})")?;
+    }
+    Ok(())
+}
+
 fn format_datetime_precision_and_tz(
     f: &mut fmt::Formatter,
     sql_type: &'static str,
@@ -719,19 +849,19 @@ pub enum StructBracketKind {
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
 pub enum TimezoneInfo {
-    /// No information about time zone. E.g., TIMESTAMP
+    /// No information about time zone, e.g. TIMESTAMP
     None,
-    /// Temporal type 'WITH TIME ZONE'. E.g., TIMESTAMP WITH TIME ZONE, [standard], [Oracle]
+    /// Temporal type 'WITH TIME ZONE', e.g. TIMESTAMP WITH TIME ZONE, [SQL Standard], [Oracle]
     ///
-    /// [standard]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#datetime-type
+    /// [SQL Standard]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#datetime-type
     /// [Oracle]: https://docs.oracle.com/en/database/oracle/oracle-database/12.2/nlspg/datetime-data-types-and-time-zone-support.html#GUID-3F1C388E-C651-43D5-ADBC-1A49E5C2CA05
     WithTimeZone,
-    /// Temporal type 'WITHOUT TIME ZONE'. E.g., TIME WITHOUT TIME ZONE, [standard], [Postgresql]
+    /// Temporal type 'WITHOUT TIME ZONE', e.g. TIME WITHOUT TIME ZONE, [SQL Standard], [Postgresql]
     ///
-    /// [standard]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#datetime-type
+    /// [SQL Standard]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#datetime-type
     /// [Postgresql]: https://www.postgresql.org/docs/current/datatype-datetime.html
     WithoutTimeZone,
-    /// Postgresql specific `WITH TIME ZONE` formatting, for both TIME and TIMESTAMP. E.g., TIMETZ, [Postgresql]
+    /// Postgresql specific `WITH TIME ZONE` formatting, for both TIME and TIMESTAMP, e.g. TIMETZ, [Postgresql]
     ///
     /// [Postgresql]: https://www.postgresql.org/docs/current/datatype-datetime.html
     Tz,
@@ -760,18 +890,18 @@ impl fmt::Display for TimezoneInfo {
 }
 
 /// Additional information for `NUMERIC`, `DECIMAL`, and `DEC` data types
-/// following the 2016 [standard].
+/// following the 2016 [SQL Standard].
 ///
-/// [standard]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#exact-numeric-type
+/// [SQL Standard]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#exact-numeric-type
 #[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
 pub enum ExactNumberInfo {
-    /// No additional information e.g. `DECIMAL`
+    /// No additional information, e.g. `DECIMAL`
     None,
-    /// Only precision information e.g. `DECIMAL(10)`
+    /// Only precision information, e.g. `DECIMAL(10)`
     Precision(u64),
-    /// Precision and scale information e.g. `DECIMAL(10,2)`
+    /// Precision and scale information, e.g. `DECIMAL(10,2)`
     PrecisionAndScale(u64, u64),
 }
 
@@ -812,7 +942,7 @@ impl fmt::Display for CharacterLength {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             CharacterLength::IntegerLength { length, unit } => {
-                write!(f, "{}", length)?;
+                write!(f, "{length}")?;
                 if let Some(unit) = unit {
                     write!(f, " {unit}")?;
                 }
@@ -825,7 +955,7 @@ impl fmt::Display for CharacterLength {
     }
 }
 
-/// Possible units for characters, initially based on 2016 ANSI [standard][1].
+/// Possible units for characters, initially based on 2016 ANSI [SQL Standard][1].
 ///
 /// [1]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#char-length-units
 #[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
@@ -851,6 +981,32 @@ impl fmt::Display for CharLengthUnits {
     }
 }
 
+#[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum BinaryLength {
+    IntegerLength {
+        /// Default (if VARYING)
+        length: u64,
+    },
+    /// VARBINARY(MAX) used in T-SQL (Microsoft SQL Server)
+    Max,
+}
+
+impl fmt::Display for BinaryLength {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            BinaryLength::IntegerLength { length } => {
+                write!(f, "{length}")?;
+            }
+            BinaryLength::Max => {
+                write!(f, "MAX")?;
+            }
+        }
+        Ok(())
+    }
+}
+
 /// Represents the data type of the elements in an array (if any) as well as
 /// the syntax used to declare the array.
 ///
@@ -868,3 +1024,34 @@ pub enum ArrayElemTypeDef {
     /// `Array(Int64)`
     Parenthesis(Box<DataType>),
 }
+
+/// Represents different types of geometric shapes which are commonly used in
+/// PostgreSQL/Redshift for spatial operations and geometry-related computations.
+///
+/// [PostgreSQL]: https://www.postgresql.org/docs/9.5/functions-geometry.html
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum GeometricTypeKind {
+    Point,
+    Line,
+    LineSegment,
+    GeometricBox,
+    GeometricPath,
+    Polygon,
+    Circle,
+}
+
+impl fmt::Display for GeometricTypeKind {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            GeometricTypeKind::Point => write!(f, "point"),
+            GeometricTypeKind::Line => write!(f, "line"),
+            GeometricTypeKind::LineSegment => write!(f, "lseg"),
+            GeometricTypeKind::GeometricBox => write!(f, "box"),
+            GeometricTypeKind::GeometricPath => write!(f, "path"),
+            GeometricTypeKind::Polygon => write!(f, "polygon"),
+            GeometricTypeKind::Circle => write!(f, "circle"),
+        }
+    }
+}

src/ast/dcl.rs

@@ -173,7 +173,7 @@ impl fmt::Display for AlterRoleOperation {
                 in_database,
             } => {
                 if let Some(database_name) = in_database {
-                    write!(f, "IN DATABASE {} ", database_name)?;
+                    write!(f, "IN DATABASE {database_name} ")?;
                 }
 
                 match config_value {
@@ -187,7 +187,7 @@ impl fmt::Display for AlterRoleOperation {
                 in_database,
             } => {
                 if let Some(database_name) = in_database {
-                    write!(f, "IN DATABASE {} ", database_name)?;
+                    write!(f, "IN DATABASE {database_name} ")?;
                 }
 
                 match config_name {
@@ -218,15 +218,15 @@ impl fmt::Display for Use {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.write_str("USE ")?;
         match self {
-            Use::Catalog(name) => write!(f, "CATALOG {}", name),
-            Use::Schema(name) => write!(f, "SCHEMA {}", name),
-            Use::Database(name) => write!(f, "DATABASE {}", name),
-            Use::Warehouse(name) => write!(f, "WAREHOUSE {}", name),
-            Use::Role(name) => write!(f, "ROLE {}", name),
+            Use::Catalog(name) => write!(f, "CATALOG {name}"),
+            Use::Schema(name) => write!(f, "SCHEMA {name}"),
+            Use::Database(name) => write!(f, "DATABASE {name}"),
+            Use::Warehouse(name) => write!(f, "WAREHOUSE {name}"),
+            Use::Role(name) => write!(f, "ROLE {name}"),
             Use::SecondaryRoles(secondary_roles) => {
-                write!(f, "SECONDARY ROLES {}", secondary_roles)
+                write!(f, "SECONDARY ROLES {secondary_roles}")
             }
-            Use::Object(name) => write!(f, "{}", name),
+            Use::Object(name) => write!(f, "{name}"),
             Use::Default => write!(f, "DEFAULT"),
         }
     }

src/ast/ddl.rs

@@ -30,21 +30,48 @@ use sqlparser_derive::{Visit, VisitMut};
 
 use crate::ast::value::escape_single_quote_string;
 use crate::ast::{
-    display_comma_separated, display_separated, CreateFunctionBody, CreateFunctionUsing, DataType,
-    Expr, FunctionBehavior, FunctionCalledOnNull, FunctionDeterminismSpecifier, FunctionParallel,
-    Ident, MySQLColumnPosition, ObjectName, OperateFunctionArg, OrderByExpr, ProjectionSelect,
-    SequenceOptions, SqlOption, Tag, Value,
+    display_comma_separated, display_separated, ArgMode, CommentDef, CreateFunctionBody,
+    CreateFunctionUsing, DataType, Expr, FunctionBehavior, FunctionCalledOnNull,
+    FunctionDeterminismSpecifier, FunctionParallel, Ident, IndexColumn, MySQLColumnPosition,
+    ObjectName, OperateFunctionArg, OrderByExpr, ProjectionSelect, SequenceOptions, SqlOption, Tag,
+    Value, ValueWithSpan,
 };
 use crate::keywords::Keyword;
 use crate::tokenizer::Token;
 
+/// ALTER TABLE operation REPLICA IDENTITY values
+/// See [Postgres ALTER TABLE docs](https://www.postgresql.org/docs/current/sql-altertable.html)
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum ReplicaIdentity {
+    None,
+    Full,
+    Default,
+    Index(Ident),
+}
+
+impl fmt::Display for ReplicaIdentity {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            ReplicaIdentity::None => f.write_str("NONE"),
+            ReplicaIdentity::Full => f.write_str("FULL"),
+            ReplicaIdentity::Default => f.write_str("DEFAULT"),
+            ReplicaIdentity::Index(idx) => write!(f, "USING INDEX {idx}"),
+        }
+    }
+}
+
 /// An `ALTER TABLE` (`Statement::AlterTable`) operation
 #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
 pub enum AlterTableOperation {
-    /// `ADD <table_constraint>`
-    AddConstraint(TableConstraint),
+    /// `ADD <table_constraint> [NOT VALID]`
+    AddConstraint {
+        constraint: TableConstraint,
+        not_valid: bool,
+    },
     /// `ADD [COLUMN] [IF NOT EXISTS] <column_def>`
     AddColumn {
         /// `[COLUMN]`.
@@ -65,7 +92,6 @@ pub enum AlterTableOperation {
         name: Ident,
         select: ProjectionSelect,
     },
-
     /// `DROP PROJECTION [IF EXISTS] name`
     ///
     /// Note: this is a ClickHouse-specific operation.
@@ -74,7 +100,6 @@ pub enum AlterTableOperation {
         if_exists: bool,
         name: Ident,
     },
-
     /// `MATERIALIZE PROJECTION [IF EXISTS] name [IN PARTITION partition_name]`
     ///
     ///  Note: this is a ClickHouse-specific operation.
@@ -84,7 +109,6 @@ pub enum AlterTableOperation {
         name: Ident,
         partition: Option<Ident>,
     },
-
     /// `CLEAR PROJECTION [IF EXISTS] name [IN PARTITION partition_name]`
     ///
     /// Note: this is a ClickHouse-specific operation.
@@ -94,7 +118,6 @@ pub enum AlterTableOperation {
         name: Ident,
         partition: Option<Ident>,
     },
-
     /// `DISABLE ROW LEVEL SECURITY`
     ///
     /// Note: this is a PostgreSQL-specific operation.
@@ -117,9 +140,10 @@ pub enum AlterTableOperation {
         name: Ident,
         drop_behavior: Option<DropBehavior>,
     },
-    /// `DROP [ COLUMN ] [ IF EXISTS ] <column_name> [ CASCADE ]`
+    /// `DROP [ COLUMN ] [ IF EXISTS ] <column_name> [ , <column_name>, ... ] [ CASCADE ]`
     DropColumn {
-        column_name: Ident,
+        has_column_keyword: bool,
+        column_names: Vec<Ident>,
         if_exists: bool,
         drop_behavior: Option<DropBehavior>,
     },
@@ -154,8 +178,24 @@ pub enum AlterTableOperation {
     },
     /// `DROP PRIMARY KEY`
     ///
-    /// Note: this is a MySQL-specific operation.
+    /// Note: this is a [MySQL]-specific operation.
+    ///
+    /// [MySQL]: https://dev.mysql.com/doc/refman/8.4/en/alter-table.html
     DropPrimaryKey,
+    /// `DROP FOREIGN KEY <fk_symbol>`
+    ///
+    /// Note: this is a [MySQL]-specific operation.
+    ///
+    /// [MySQL]: https://dev.mysql.com/doc/refman/8.4/en/alter-table.html
+    DropForeignKey {
+        name: Ident,
+    },
+    /// `DROP INDEX <index_name>`
+    ///
+    /// [MySQL]: https://dev.mysql.com/doc/refman/8.4/en/alter-table.html
+    DropIndex {
+        name: Ident,
+    },
     /// `ENABLE ALWAYS RULE rewrite_rule_name`
     ///
     /// Note: this is a PostgreSQL-specific operation.
@@ -201,6 +241,13 @@ pub enum AlterTableOperation {
         old_partitions: Vec<Expr>,
         new_partitions: Vec<Expr>,
     },
+    /// REPLICA IDENTITY { DEFAULT | USING INDEX index_name | FULL | NOTHING }
+    ///
+    /// Note: this is a PostgreSQL-specific operation.
+    /// Please refer to [PostgreSQL documentation](https://www.postgresql.org/docs/current/sql-altertable.html)
+    ReplicaIdentity {
+        identity: ReplicaIdentity,
+    },
     /// Add Partitions
     AddPartitions {
         if_not_exists: bool,
@@ -272,6 +319,38 @@ pub enum AlterTableOperation {
     DropClusteringKey,
     SuspendRecluster,
     ResumeRecluster,
+    /// `ALGORITHM [=] { DEFAULT | INSTANT | INPLACE | COPY }`
+    ///
+    /// [MySQL]-specific table alter algorithm.
+    ///
+    /// [MySQL]: https://dev.mysql.com/doc/refman/8.4/en/alter-table.html
+    Algorithm {
+        equals: bool,
+        algorithm: AlterTableAlgorithm,
+    },
+
+    /// `LOCK [=] { DEFAULT | NONE | SHARED | EXCLUSIVE }`
+    ///
+    /// [MySQL]-specific table alter lock.
+    ///
+    /// [MySQL]: https://dev.mysql.com/doc/refman/8.4/en/alter-table.html
+    Lock {
+        equals: bool,
+        lock: AlterTableLock,
+    },
+    /// `AUTO_INCREMENT [=] <value>`
+    ///
+    /// [MySQL]-specific table option for raising current auto increment value.
+    ///
+    /// [MySQL]: https://dev.mysql.com/doc/refman/8.4/en/alter-table.html
+    AutoIncrement {
+        equals: bool,
+        value: ValueWithSpan,
+    },
+    /// `VALIDATE CONSTRAINT <name>`
+    ValidateConstraint {
+        name: Ident,
+    },
 }
 
 /// An `ALTER Policy` (`Statement::AlterPolicy`) operation
@@ -317,6 +396,54 @@ impl fmt::Display for AlterPolicyOperation {
     }
 }
 
+/// [MySQL] `ALTER TABLE` algorithm.
+///
+/// [MySQL]: https://dev.mysql.com/doc/refman/8.4/en/alter-table.html
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum AlterTableAlgorithm {
+    Default,
+    Instant,
+    Inplace,
+    Copy,
+}
+
+impl fmt::Display for AlterTableAlgorithm {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str(match self {
+            Self::Default => "DEFAULT",
+            Self::Instant => "INSTANT",
+            Self::Inplace => "INPLACE",
+            Self::Copy => "COPY",
+        })
+    }
+}
+
+/// [MySQL] `ALTER TABLE` lock.
+///
+/// [MySQL]: https://dev.mysql.com/doc/refman/8.4/en/alter-table.html
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum AlterTableLock {
+    Default,
+    None,
+    Shared,
+    Exclusive,
+}
+
+impl fmt::Display for AlterTableLock {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str(match self {
+            Self::Default => "DEFAULT",
+            Self::None => "NONE",
+            Self::Shared => "SHARED",
+            Self::Exclusive => "EXCLUSIVE",
+        })
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
@@ -330,7 +457,7 @@ pub enum Owner {
 impl fmt::Display for Owner {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            Owner::Ident(ident) => write!(f, "{}", ident),
+            Owner::Ident(ident) => write!(f, "{ident}"),
             Owner::CurrentRole => write!(f, "CURRENT_ROLE"),
             Owner::CurrentUser => write!(f, "CURRENT_USER"),
             Owner::SessionUser => write!(f, "SESSION_USER"),
@@ -338,6 +465,23 @@ impl fmt::Display for Owner {
     }
 }
 
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum AlterConnectorOwner {
+    User(Ident),
+    Role(Ident),
+}
+
+impl fmt::Display for AlterConnectorOwner {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            AlterConnectorOwner::User(ident) => write!(f, "USER {ident}"),
+            AlterConnectorOwner::Role(ident) => write!(f, "ROLE {ident}"),
+        }
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
@@ -357,7 +501,16 @@ impl fmt::Display for AlterTableOperation {
                 display_separated(new_partitions, " "),
                 ine = if *if_not_exists { " IF NOT EXISTS" } else { "" }
             ),
-            AlterTableOperation::AddConstraint(c) => write!(f, "ADD {c}"),
+            AlterTableOperation::AddConstraint {
+                not_valid,
+                constraint,
+            } => {
+                write!(f, "ADD {constraint}")?;
+                if *not_valid {
+                    write!(f, " NOT VALID")?;
+                }
+                Ok(())
+            }
             AlterTableOperation::AddColumn {
                 column_keyword,
                 if_not_exists,
@@ -388,14 +541,22 @@ impl fmt::Display for AlterTableOperation {
                 if *if_not_exists {
                     write!(f, " IF NOT EXISTS")?;
                 }
-                write!(f, " {} ({})", name, query)
+                write!(f, " {name} ({query})")
+            }
+            AlterTableOperation::Algorithm { equals, algorithm } => {
+                write!(
+                    f,
+                    "ALGORITHM {}{}",
+                    if *equals { "= " } else { "" },
+                    algorithm
+                )
             }
             AlterTableOperation::DropProjection { if_exists, name } => {
                 write!(f, "DROP PROJECTION")?;
                 if *if_exists {
                     write!(f, " IF EXISTS")?;
                 }
-                write!(f, " {}", name)
+                write!(f, " {name}")
             }
             AlterTableOperation::MaterializeProjection {
                 if_exists,
@@ -406,9 +567,9 @@ impl fmt::Display for AlterTableOperation {
                 if *if_exists {
                     write!(f, " IF EXISTS")?;
                 }
-                write!(f, " {}", name)?;
+                write!(f, " {name}")?;
                 if let Some(partition) = partition {
-                    write!(f, " IN PARTITION {}", partition)?;
+                    write!(f, " IN PARTITION {partition}")?;
                 }
                 Ok(())
             }
@@ -421,9 +582,9 @@ impl fmt::Display for AlterTableOperation {
                 if *if_exists {
                     write!(f, " IF EXISTS")?;
                 }
-                write!(f, " {}", name)?;
+                write!(f, " {name}")?;
                 if let Some(partition) = partition {
-                    write!(f, " IN PARTITION {}", partition)?;
+                    write!(f, " IN PARTITION {partition}")?;
                 }
                 Ok(())
             }
@@ -466,15 +627,19 @@ impl fmt::Display for AlterTableOperation {
                 )
             }
             AlterTableOperation::DropPrimaryKey => write!(f, "DROP PRIMARY KEY"),
+            AlterTableOperation::DropForeignKey { name } => write!(f, "DROP FOREIGN KEY {name}"),
+            AlterTableOperation::DropIndex { name } => write!(f, "DROP INDEX {name}"),
             AlterTableOperation::DropColumn {
-                column_name,
+                has_column_keyword,
+                column_names: column_name,
                 if_exists,
                 drop_behavior,
             } => write!(
                 f,
-                "DROP COLUMN {}{}{}",
+                "DROP {}{}{}{}",
+                if *has_column_keyword { "COLUMN " } else { "" },
                 if *if_exists { "IF EXISTS " } else { "" },
-                column_name,
+                display_comma_separated(column_name),
                 match drop_behavior {
                     None => "",
                     Some(DropBehavior::Restrict) => " RESTRICT",
@@ -609,6 +774,23 @@ impl fmt::Display for AlterTableOperation {
                 write!(f, "RESUME RECLUSTER")?;
                 Ok(())
             }
+            AlterTableOperation::AutoIncrement { equals, value } => {
+                write!(
+                    f,
+                    "AUTO_INCREMENT {}{}",
+                    if *equals { "= " } else { "" },
+                    value
+                )
+            }
+            AlterTableOperation::Lock { equals, lock } => {
+                write!(f, "LOCK {}{}", if *equals { "= " } else { "" }, lock)
+            }
+            AlterTableOperation::ReplicaIdentity { identity } => {
+                write!(f, "REPLICA IDENTITY {identity}")
+            }
+            AlterTableOperation::ValidateConstraint { name } => {
+                write!(f, "VALIDATE CONSTRAINT {name}")
+            }
         }
     }
 }
@@ -623,6 +805,95 @@ impl fmt::Display for AlterIndexOperation {
     }
 }
 
+/// An `ALTER TYPE` statement (`Statement::AlterType`)
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct AlterType {
+    pub name: ObjectName,
+    pub operation: AlterTypeOperation,
+}
+
+/// An [AlterType] operation
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum AlterTypeOperation {
+    Rename(AlterTypeRename),
+    AddValue(AlterTypeAddValue),
+    RenameValue(AlterTypeRenameValue),
+}
+
+/// See [AlterTypeOperation::Rename]
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct AlterTypeRename {
+    pub new_name: Ident,
+}
+
+/// See [AlterTypeOperation::AddValue]
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct AlterTypeAddValue {
+    pub if_not_exists: bool,
+    pub value: Ident,
+    pub position: Option<AlterTypeAddValuePosition>,
+}
+
+/// See [AlterTypeAddValue]
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum AlterTypeAddValuePosition {
+    Before(Ident),
+    After(Ident),
+}
+
+/// See [AlterTypeOperation::RenameValue]
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct AlterTypeRenameValue {
+    pub from: Ident,
+    pub to: Ident,
+}
+
+impl fmt::Display for AlterTypeOperation {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Self::Rename(AlterTypeRename { new_name }) => {
+                write!(f, "RENAME TO {new_name}")
+            }
+            Self::AddValue(AlterTypeAddValue {
+                if_not_exists,
+                value,
+                position,
+            }) => {
+                write!(f, "ADD VALUE")?;
+                if *if_not_exists {
+                    write!(f, " IF NOT EXISTS")?;
+                }
+                write!(f, " {value}")?;
+                match position {
+                    Some(AlterTypeAddValuePosition::Before(neighbor_value)) => {
+                        write!(f, " BEFORE {neighbor_value}")?;
+                    }
+                    Some(AlterTypeAddValuePosition::After(neighbor_value)) => {
+                        write!(f, " AFTER {neighbor_value}")?;
+                    }
+                    None => {}
+                };
+                Ok(())
+            }
+            Self::RenameValue(AlterTypeRenameValue { from, to }) => {
+                write!(f, "RENAME VALUE {from} TO {to}")
+            }
+        }
+    }
+}
+
 /// An `ALTER COLUMN` (`Statement::AlterTable`) operation
 #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
@@ -641,7 +912,10 @@ pub enum AlterColumnOperation {
         data_type: DataType,
         /// PostgreSQL specific
         using: Option<Expr>,
+        /// Set to true if the statement includes the `SET DATA TYPE` keywords
+        had_set: bool,
     },
+
     /// `ADD GENERATED { ALWAYS | BY DEFAULT } AS IDENTITY [ ( sequence_options ) ]`
     ///
     /// Note: this is a PostgreSQL-specific operation.
@@ -659,15 +933,22 @@ impl fmt::Display for AlterColumnOperation {
             AlterColumnOperation::SetDefault { value } => {
                 write!(f, "SET DEFAULT {value}")
             }
-            AlterColumnOperation::DropDefault {} => {
+            AlterColumnOperation::DropDefault => {
                 write!(f, "DROP DEFAULT")
             }
-            AlterColumnOperation::SetDataType { data_type, using } => {
-                if let Some(expr) = using {
-                    write!(f, "SET DATA TYPE {data_type} USING {expr}")
-                } else {
-                    write!(f, "SET DATA TYPE {data_type}")
+            AlterColumnOperation::SetDataType {
+                data_type,
+                using,
+                had_set,
+            } => {
+                if *had_set {
+                    write!(f, "SET DATA ")?;
                 }
+                write!(f, "TYPE {data_type}")?;
+                if let Some(expr) = using {
+                    write!(f, " USING {expr}")?;
+                }
+                Ok(())
             }
             AlterColumnOperation::AddGenerated {
                 generated_as,
@@ -727,7 +1008,7 @@ pub enum TableConstraint {
         /// [1]: IndexType
         index_type: Option<IndexType>,
         /// Identifiers of the columns that are unique.
-        columns: Vec<Ident>,
+        columns: Vec<IndexColumn>,
         index_options: Vec<IndexOption>,
         characteristics: Option<ConstraintCharacteristics>,
         /// Optional Postgres nulls handling: `[ NULLS [ NOT ] DISTINCT ]`
@@ -763,7 +1044,7 @@ pub enum TableConstraint {
         /// [1]: IndexType
         index_type: Option<IndexType>,
         /// Identifiers of the columns that form the primary key.
-        columns: Vec<Ident>,
+        columns: Vec<IndexColumn>,
         index_options: Vec<IndexOption>,
         characteristics: Option<ConstraintCharacteristics>,
     },
@@ -774,6 +1055,9 @@ pub enum TableConstraint {
     /// }`).
     ForeignKey {
         name: Option<Ident>,
+        /// MySQL-specific field
+        /// <https://dev.mysql.com/doc/refman/8.4/en/create-table-foreign-keys.html>
+        index_name: Option<Ident>,
         columns: Vec<Ident>,
         foreign_table: ObjectName,
         referred_columns: Vec<Ident>,
@@ -781,10 +1065,13 @@ pub enum TableConstraint {
         on_update: Option<ReferentialAction>,
         characteristics: Option<ConstraintCharacteristics>,
     },
-    /// `[ CONSTRAINT <name> ] CHECK (<expr>)`
+    /// `[ CONSTRAINT <name> ] CHECK (<expr>) [[NOT] ENFORCED]`
     Check {
         name: Option<Ident>,
         expr: Box<Expr>,
+        /// MySQL-specific syntax
+        /// <https://dev.mysql.com/doc/refman/8.4/en/create-table.html>
+        enforced: Option<bool>,
     },
     /// MySQLs [index definition][1] for index creation. Not present on ANSI so, for now, the usage
     /// is restricted to MySQL, as no other dialects that support this syntax were found.
@@ -802,7 +1089,7 @@ pub enum TableConstraint {
         /// [1]: IndexType
         index_type: Option<IndexType>,
         /// Referred column identifier list.
-        columns: Vec<Ident>,
+        columns: Vec<IndexColumn>,
     },
     /// MySQLs [fulltext][1] definition. Since the [`SPATIAL`][2] definition is exactly the same,
     /// and MySQL displays both the same way, it is part of this definition as well.
@@ -825,7 +1112,7 @@ pub enum TableConstraint {
         /// Optional index name.
         opt_index_name: Option<Ident>,
         /// Referred column identifier list.
-        columns: Vec<Ident>,
+        columns: Vec<IndexColumn>,
     },
 }
 
@@ -884,6 +1171,7 @@ impl fmt::Display for TableConstraint {
             }
             TableConstraint::ForeignKey {
                 name,
+                index_name,
                 columns,
                 foreign_table,
                 referred_columns,
@@ -893,8 +1181,9 @@ impl fmt::Display for TableConstraint {
             } => {
                 write!(
                     f,
-                    "{}FOREIGN KEY ({}) REFERENCES {}",
+                    "{}FOREIGN KEY{} ({}) REFERENCES {}",
                     display_constraint_name(name),
+                    display_option_spaced(index_name),
                     display_comma_separated(columns),
                     foreign_table,
                 )?;
@@ -908,12 +1197,21 @@ impl fmt::Display for TableConstraint {
                     write!(f, " ON UPDATE {action}")?;
                 }
                 if let Some(characteristics) = characteristics {
-                    write!(f, " {}", characteristics)?;
+                    write!(f, " {characteristics}")?;
                 }
                 Ok(())
             }
-            TableConstraint::Check { name, expr } => {
-                write!(f, "{}CHECK ({})", display_constraint_name(name), expr)
+            TableConstraint::Check {
+                name,
+                expr,
+                enforced,
+            } => {
+                write!(f, "{}CHECK ({})", display_constraint_name(name), expr)?;
+                if let Some(b) = enforced {
+                    write!(f, " {}", if *b { "ENFORCED" } else { "NOT ENFORCED" })
+                } else {
+                    Ok(())
+                }
             }
             TableConstraint::Index {
                 display_as_key,
@@ -1013,13 +1311,20 @@ impl fmt::Display for KeyOrIndexDisplay {
 /// [1]: https://dev.mysql.com/doc/refman/8.0/en/create-table.html
 /// [2]: https://dev.mysql.com/doc/refman/8.0/en/create-index.html
 /// [3]: https://www.postgresql.org/docs/14/sql-createindex.html
-#[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
 pub enum IndexType {
     BTree,
     Hash,
-    // TODO add Postgresql's possible indexes
+    GIN,
+    GiST,
+    SPGiST,
+    BRIN,
+    Bloom,
+    /// Users may define their own index types, which would
+    /// not be covered by the above variants.
+    Custom(Ident),
 }
 
 impl fmt::Display for IndexType {
@@ -1027,6 +1332,12 @@ impl fmt::Display for IndexType {
         match self {
             Self::BTree => write!(f, "BTREE"),
             Self::Hash => write!(f, "HASH"),
+            Self::GIN => write!(f, "GIN"),
+            Self::GiST => write!(f, "GIST"),
+            Self::SPGiST => write!(f, "SPGIST"),
+            Self::BRIN => write!(f, "BRIN"),
+            Self::Bloom => write!(f, "BLOOM"),
+            Self::Custom(name) => write!(f, "{name}"),
         }
     }
 }
@@ -1054,9 +1365,9 @@ impl fmt::Display for IndexOption {
     }
 }
 
-/// [Postgres] unique index nulls handling option: `[ NULLS [ NOT ] DISTINCT ]`
+/// [PostgreSQL] unique index nulls handling option: `[ NULLS [ NOT ] DISTINCT ]`
 ///
-/// [Postgres]: https://www.postgresql.org/docs/17/sql-altertable.html
+/// [PostgreSQL]: https://www.postgresql.org/docs/17/sql-altertable.html
 #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
@@ -1085,11 +1396,16 @@ impl fmt::Display for NullsDistinctOption {
 pub struct ProcedureParam {
     pub name: Ident,
     pub data_type: DataType,
+    pub mode: Option<ArgMode>,
 }
 
 impl fmt::Display for ProcedureParam {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{} {}", self.name, self.data_type)
+        if let Some(mode) = &self.mode {
+            write!(f, "{mode} {} {}", self.name, self.data_type)
+        } else {
+            write!(f, "{} {}", self.name, self.data_type)
+        }
     }
 }
 
@@ -1100,7 +1416,6 @@ impl fmt::Display for ProcedureParam {
 pub struct ColumnDef {
     pub name: Ident,
     pub data_type: DataType,
-    pub collation: Option<ObjectName>,
     pub options: Vec<ColumnOptionDef>,
 }
 
@@ -1111,9 +1426,6 @@ impl fmt::Display for ColumnDef {
         } else {
             write!(f, "{} {}", self.name, self.data_type)?;
         }
-        if let Some(collation) = &self.collation {
-            write!(f, " COLLATE {collation}")?;
-        }
         for option in &self.options {
             write!(f, " {option}")?;
         }
@@ -1143,17 +1455,41 @@ impl fmt::Display for ColumnDef {
 pub struct ViewColumnDef {
     pub name: Ident,
     pub data_type: Option<DataType>,
-    pub options: Option<Vec<ColumnOption>>,
+    pub options: Option<ColumnOptions>,
+}
+
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum ColumnOptions {
+    CommaSeparated(Vec<ColumnOption>),
+    SpaceSeparated(Vec<ColumnOption>),
+}
+
+impl ColumnOptions {
+    pub fn as_slice(&self) -> &[ColumnOption] {
+        match self {
+            ColumnOptions::CommaSeparated(options) => options.as_slice(),
+            ColumnOptions::SpaceSeparated(options) => options.as_slice(),
+        }
+    }
 }
 
 impl fmt::Display for ViewColumnDef {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{}", self.name)?;
         if let Some(data_type) = self.data_type.as_ref() {
-            write!(f, " {}", data_type)?;
+            write!(f, " {data_type}")?;
         }
         if let Some(options) = self.options.as_ref() {
-            write!(f, " {}", display_comma_separated(options.as_slice()))?;
+            match options {
+                ColumnOptions::CommaSeparated(column_options) => {
+                    write!(f, " {}", display_comma_separated(column_options.as_slice()))?;
+                }
+                ColumnOptions::SpaceSeparated(column_options) => {
+                    write!(f, " {}", display_separated(column_options.as_slice(), " "))?
+                }
+            }
         }
         Ok(())
     }
@@ -1373,7 +1709,7 @@ pub struct ColumnPolicyProperty {
     /// ```
     /// [Snowflake]: https://docs.snowflake.com/en/sql-reference/sql/create-table
     pub with: bool,
-    pub policy_name: Ident,
+    pub policy_name: ObjectName,
     pub using_columns: Option<Vec<Ident>>,
 }
 
@@ -1460,6 +1796,7 @@ pub enum ColumnOption {
     /// - ...
     DialectSpecific(Vec<Token>),
     CharacterSet(ObjectName),
+    Collation(ObjectName),
     Comment(String),
     OnUpdate(Expr),
     /// `Generated`s are modifiers that follow a column definition in a `CREATE
@@ -1506,6 +1843,13 @@ pub enum ColumnOption {
     /// ```
     /// [Snowflake]: https://docs.snowflake.com/en/sql-reference/sql/create-table
     Tags(TagsColumnOption),
+    /// MySQL specific: Spatial reference identifier
+    /// Syntax:
+    /// ```sql
+    /// CREATE TABLE geom (g GEOMETRY NOT NULL SRID 4326);
+    /// ```
+    /// [MySQL]: https://dev.mysql.com/doc/refman/8.4/en/creating-spatial-indexes.html
+    Srid(Box<Expr>),
 }
 
 impl fmt::Display for ColumnOption {
@@ -1530,7 +1874,7 @@ impl fmt::Display for ColumnOption {
             } => {
                 write!(f, "{}", if *is_primary { "PRIMARY KEY" } else { "UNIQUE" })?;
                 if let Some(characteristics) = characteristics {
-                    write!(f, " {}", characteristics)?;
+                    write!(f, " {characteristics}")?;
                 }
                 Ok(())
             }
@@ -1552,13 +1896,14 @@ impl fmt::Display for ColumnOption {
                     write!(f, " ON UPDATE {action}")?;
                 }
                 if let Some(characteristics) = characteristics {
-                    write!(f, " {}", characteristics)?;
+                    write!(f, " {characteristics}")?;
                 }
                 Ok(())
             }
             Check(expr) => write!(f, "CHECK ({expr})"),
             DialectSpecific(val) => write!(f, "{}", display_separated(val, " ")),
             CharacterSet(n) => write!(f, "CHARACTER SET {n}"),
+            Collation(n) => write!(f, "COLLATE {n}"),
             Comment(v) => write!(f, "COMMENT '{}'", escape_single_quote_string(v)),
             OnUpdate(expr) => write!(f, "ON UPDATE {expr}"),
             Generated {
@@ -1611,7 +1956,7 @@ impl fmt::Display for ColumnOption {
                 write!(f, "{parameters}")
             }
             OnConflict(keyword) => {
-                write!(f, "ON CONFLICT {:?}", keyword)?;
+                write!(f, "ON CONFLICT {keyword:?}")?;
                 Ok(())
             }
             Policy(parameters) => {
@@ -1620,6 +1965,9 @@ impl fmt::Display for ColumnOption {
             Tags(tags) => {
                 write!(f, "{tags}")
             }
+            Srid(srid) => {
+                write!(f, "SRID {srid}")
+            }
         }
     }
 }
@@ -1933,10 +2281,63 @@ impl fmt::Display for ClusteredBy {
     }
 }
 
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+/// ```sql
+/// CREATE DOMAIN name [ AS ] data_type
+///         [ COLLATE collation ]
+///         [ DEFAULT expression ]
+///         [ domain_constraint [ ... ] ]
+///
+///     where domain_constraint is:
+///
+///     [ CONSTRAINT constraint_name ]
+///     { NOT NULL | NULL | CHECK (expression) }
+/// ```
+/// See [PostgreSQL](https://www.postgresql.org/docs/current/sql-createdomain.html)
+pub struct CreateDomain {
+    /// The name of the domain to be created.
+    pub name: ObjectName,
+    /// The data type of the domain.
+    pub data_type: DataType,
+    /// The collation of the domain.
+    pub collation: Option<Ident>,
+    /// The default value of the domain.
+    pub default: Option<Expr>,
+    /// The constraints of the domain.
+    pub constraints: Vec<TableConstraint>,
+}
+
+impl fmt::Display for CreateDomain {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            f,
+            "CREATE DOMAIN {name} AS {data_type}",
+            name = self.name,
+            data_type = self.data_type
+        )?;
+        if let Some(collation) = &self.collation {
+            write!(f, " COLLATE {collation}")?;
+        }
+        if let Some(default) = &self.default {
+            write!(f, " DEFAULT {default}")?;
+        }
+        if !self.constraints.is_empty() {
+            write!(f, " {}", display_separated(&self.constraints, " "))?;
+        }
+        Ok(())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
 pub struct CreateFunction {
+    /// True if this is a `CREATE OR ALTER FUNCTION` statement
+    ///
+    /// [MsSql](https://learn.microsoft.com/en-us/sql/t-sql/statements/create-function-transact-sql?view=sql-server-ver16#or-alter)
+    pub or_alter: bool,
     pub or_replace: bool,
     pub temporary: bool,
     pub if_not_exists: bool,
@@ -1955,15 +2356,15 @@ pub struct CreateFunction {
     ///
     /// IMMUTABLE | STABLE | VOLATILE
     ///
-    /// [Postgres](https://www.postgresql.org/docs/current/sql-createfunction.html)
+    /// [PostgreSQL](https://www.postgresql.org/docs/current/sql-createfunction.html)
     pub behavior: Option<FunctionBehavior>,
     /// CALLED ON NULL INPUT | RETURNS NULL ON NULL INPUT | STRICT
     ///
-    /// [Postgres](https://www.postgresql.org/docs/current/sql-createfunction.html)
+    /// [PostgreSQL](https://www.postgresql.org/docs/current/sql-createfunction.html)
     pub called_on_null: Option<FunctionCalledOnNull>,
     /// PARALLEL { UNSAFE | RESTRICTED | SAFE }
     ///
-    /// [Postgres](https://www.postgresql.org/docs/current/sql-createfunction.html)
+    /// [PostgreSQL](https://www.postgresql.org/docs/current/sql-createfunction.html)
     pub parallel: Option<FunctionParallel>,
     /// USING ... (Hive only)
     pub using: Option<CreateFunctionUsing>,
@@ -1999,9 +2400,10 @@ impl fmt::Display for CreateFunction {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(
             f,
-            "CREATE {or_replace}{temp}FUNCTION {if_not_exists}{name}",
+            "CREATE {or_alter}{or_replace}{temp}FUNCTION {if_not_exists}{name}",
             name = self.name,
             temp = if self.temporary { "TEMPORARY " } else { "" },
+            or_alter = if self.or_alter { "OR ALTER " } else { "" },
             or_replace = if self.or_replace { "OR REPLACE " } else { "" },
             if_not_exists = if self.if_not_exists {
                 "IF NOT EXISTS "
@@ -2039,6 +2441,12 @@ impl fmt::Display for CreateFunction {
         if let Some(CreateFunctionBody::Return(function_body)) = &self.function_body {
             write!(f, " RETURN {function_body}")?;
         }
+        if let Some(CreateFunctionBody::AsReturnExpr(function_body)) = &self.function_body {
+            write!(f, " AS RETURN {function_body}")?;
+        }
+        if let Some(CreateFunctionBody::AsReturnSelect(function_body)) = &self.function_body {
+            write!(f, " AS RETURN {function_body}")?;
+        }
         if let Some(using) = &self.using {
             write!(f, " {using}")?;
         }
@@ -2052,6 +2460,67 @@ impl fmt::Display for CreateFunction {
         if let Some(CreateFunctionBody::AsAfterOptions(function_body)) = &self.function_body {
             write!(f, " AS {function_body}")?;
         }
+        if let Some(CreateFunctionBody::AsBeginEnd(bes)) = &self.function_body {
+            write!(f, " AS {bes}")?;
+        }
+        Ok(())
+    }
+}
+
+/// ```sql
+/// CREATE CONNECTOR [IF NOT EXISTS] connector_name
+/// [TYPE datasource_type]
+/// [URL datasource_url]
+/// [COMMENT connector_comment]
+/// [WITH DCPROPERTIES(property_name=property_value, ...)]
+/// ```
+///
+/// [Hive](https://cwiki.apache.org/confluence/pages/viewpage.action?pageId=27362034#LanguageManualDDL-CreateDataConnectorCreateConnector)
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct CreateConnector {
+    pub name: Ident,
+    pub if_not_exists: bool,
+    pub connector_type: Option<String>,
+    pub url: Option<String>,
+    pub comment: Option<CommentDef>,
+    pub with_dcproperties: Option<Vec<SqlOption>>,
+}
+
+impl fmt::Display for CreateConnector {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            f,
+            "CREATE CONNECTOR {if_not_exists}{name}",
+            if_not_exists = if self.if_not_exists {
+                "IF NOT EXISTS "
+            } else {
+                ""
+            },
+            name = self.name,
+        )?;
+
+        if let Some(connector_type) = &self.connector_type {
+            write!(f, " TYPE '{connector_type}'")?;
+        }
+
+        if let Some(url) = &self.url {
+            write!(f, " URL '{url}'")?;
+        }
+
+        if let Some(comment) = &self.comment {
+            write!(f, " COMMENT = '{comment}'")?;
+        }
+
+        if let Some(with_dcproperties) = &self.with_dcproperties {
+            write!(
+                f,
+                " WITH DCPROPERTIES({})",
+                display_comma_separated(with_dcproperties)
+            )?;
+        }
+
         Ok(())
     }
 }

src/ast/dml.rs

@@ -29,16 +29,38 @@ use serde::{Deserialize, Serialize};
 #[cfg(feature = "visitor")]
 use sqlparser_derive::{Visit, VisitMut};
 
+use crate::display_utils::{indented_list, DisplayCommaSeparated, Indent, NewLine, SpaceOrNewline};
+
 pub use super::ddl::{ColumnDef, TableConstraint};
 
 use super::{
     display_comma_separated, display_separated, query::InputFormatClause, Assignment, ClusteredBy,
-    CommentDef, Expr, FileFormat, FromTable, HiveDistributionStyle, HiveFormat, HiveIOFormat,
-    HiveRowFormat, Ident, InsertAliases, MysqlInsertPriority, ObjectName, OnCommit, OnInsert,
-    OneOrManyWithParens, OrderByExpr, Query, RowAccessPolicy, SelectItem, Setting, SqlOption,
-    SqliteOnConflict, TableEngine, TableObject, TableWithJoins, Tag, WrappedCollection,
+    CommentDef, CreateTableOptions, Expr, FileFormat, FromTable, HiveDistributionStyle, HiveFormat,
+    HiveIOFormat, HiveRowFormat, Ident, IndexType, InsertAliases, MysqlInsertPriority, ObjectName,
+    OnCommit, OnInsert, OneOrManyWithParens, OrderByExpr, Query, RowAccessPolicy, SelectItem,
+    Setting, SqliteOnConflict, StorageSerializationPolicy, TableObject, TableWithJoins, Tag,
+    WrappedCollection,
 };
 
+/// Index column type.
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct IndexColumn {
+    pub column: OrderByExpr,
+    pub operator_class: Option<Ident>,
+}
+
+impl Display for IndexColumn {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.column)?;
+        if let Some(operator_class) = &self.operator_class {
+            write!(f, " {operator_class}")?;
+        }
+        Ok(())
+    }
+}
+
 /// CREATE INDEX statement.
 #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
@@ -48,8 +70,8 @@ pub struct CreateIndex {
     pub name: Option<ObjectName>,
     #[cfg_attr(feature = "visitor", visit(with = "visit_relation"))]
     pub table_name: ObjectName,
-    pub using: Option<Ident>,
-    pub columns: Vec<OrderByExpr>,
+    pub using: Option<IndexType>,
+    pub columns: Vec<IndexColumn>,
     pub unique: bool,
     pub concurrently: bool,
     pub if_not_exists: bool,
@@ -117,6 +139,7 @@ pub struct CreateTable {
     pub if_not_exists: bool,
     pub transient: bool,
     pub volatile: bool,
+    pub iceberg: bool,
     /// Table name
     #[cfg_attr(feature = "visitor", visit(with = "visit_relation"))]
     pub name: ObjectName,
@@ -125,19 +148,17 @@ pub struct CreateTable {
     pub constraints: Vec<TableConstraint>,
     pub hive_distribution: HiveDistributionStyle,
     pub hive_formats: Option<HiveFormat>,
-    pub table_properties: Vec<SqlOption>,
-    pub with_options: Vec<SqlOption>,
+    pub table_options: CreateTableOptions,
     pub file_format: Option<FileFormat>,
     pub location: Option<String>,
     pub query: Option<Box<Query>>,
     pub without_rowid: bool,
     pub like: Option<ObjectName>,
     pub clone: Option<ObjectName>,
-    pub engine: Option<TableEngine>,
+    // For Hive dialect, the table comment is after the column definitions without `=`,
+    // so the `comment` field is optional and different than the comment field in the general options list.
+    // [Hive](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+DDL#LanguageManualDDL-CreateTable)
     pub comment: Option<CommentDef>,
-    pub auto_increment_offset: Option<u32>,
-    pub default_charset: Option<String>,
-    pub collation: Option<String>,
     pub on_commit: Option<OnCommit>,
     /// ClickHouse "ON CLUSTER" clause:
     /// <https://clickhouse.com/docs/en/sql-reference/distributed-ddl/>
@@ -154,13 +175,17 @@ pub struct CreateTable {
     pub partition_by: Option<Box<Expr>>,
     /// BigQuery: Table clustering column list.
     /// <https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language#table_option_list>
-    pub cluster_by: Option<WrappedCollection<Vec<Ident>>>,
+    /// Snowflake: Table clustering list which contains base column, expressions on base columns.
+    /// <https://docs.snowflake.com/en/user-guide/tables-clustering-keys#defining-a-clustering-key-for-a-table>
+    pub cluster_by: Option<WrappedCollection<Vec<Expr>>>,
     /// Hive: Table clustering column list.
     /// <https://cwiki.apache.org/confluence/display/Hive/LanguageManual+DDL#LanguageManualDDL-CreateTable>
     pub clustered_by: Option<ClusteredBy>,
-    /// BigQuery: Table options list.
-    /// <https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language#table_option_list>
-    pub options: Option<Vec<SqlOption>>,
+    /// Postgres `INHERITs` clause, which contains the list of tables from which
+    /// the new table inherits.
+    /// <https://www.postgresql.org/docs/current/ddl-inherit.html>
+    /// <https://www.postgresql.org/docs/current/sql-createtable.html#SQL-CREATETABLE-PARMS-INHERITS>
+    pub inherits: Option<Vec<ObjectName>>,
     /// SQLite "STRICT" clause.
     /// if the "STRICT" table-option keyword is added to the end, after the closing ")",
     /// then strict typing rules apply to that table.
@@ -192,6 +217,21 @@ pub struct CreateTable {
     /// Snowflake "WITH TAG" clause
     /// <https://docs.snowflake.com/en/sql-reference/sql/create-table>
     pub with_tags: Option<Vec<Tag>>,
+    /// Snowflake "EXTERNAL_VOLUME" clause for Iceberg tables
+    /// <https://docs.snowflake.com/en/sql-reference/sql/create-iceberg-table>
+    pub external_volume: Option<String>,
+    /// Snowflake "BASE_LOCATION" clause for Iceberg tables
+    /// <https://docs.snowflake.com/en/sql-reference/sql/create-iceberg-table>
+    pub base_location: Option<String>,
+    /// Snowflake "CATALOG" clause for Iceberg tables
+    /// <https://docs.snowflake.com/en/sql-reference/sql/create-iceberg-table>
+    pub catalog: Option<String>,
+    /// Snowflake "CATALOG_SYNC" clause for Iceberg tables
+    /// <https://docs.snowflake.com/en/sql-reference/sql/create-iceberg-table>
+    pub catalog_sync: Option<String>,
+    /// Snowflake "STORAGE_SERIALIZATION_POLICY" clause for Iceberg tables
+    /// <https://docs.snowflake.com/en/sql-reference/sql/create-iceberg-table>
+    pub storage_serialization_policy: Option<StorageSerializationPolicy>,
 }
 
 impl Display for CreateTable {
@@ -205,7 +245,7 @@ impl Display for CreateTable {
         //   `CREATE TABLE t (a INT) AS SELECT a from t2`
         write!(
             f,
-            "CREATE {or_replace}{external}{global}{temporary}{transient}{volatile}TABLE {if_not_exists}{name}",
+            "CREATE {or_replace}{external}{global}{temporary}{transient}{volatile}{iceberg}TABLE {if_not_exists}{name}",
             or_replace = if self.or_replace { "OR REPLACE " } else { "" },
             external = if self.external { "EXTERNAL " } else { "" },
             global = self.global
@@ -221,25 +261,32 @@ impl Display for CreateTable {
             temporary = if self.temporary { "TEMPORARY " } else { "" },
             transient = if self.transient { "TRANSIENT " } else { "" },
             volatile = if self.volatile { "VOLATILE " } else { "" },
+            // Only for Snowflake
+            iceberg = if self.iceberg { "ICEBERG " } else { "" },
             name = self.name,
         )?;
         if let Some(on_cluster) = &self.on_cluster {
-            write!(f, " ON CLUSTER {}", on_cluster)?;
+            write!(f, " ON CLUSTER {on_cluster}")?;
         }
         if !self.columns.is_empty() || !self.constraints.is_empty() {
-            write!(f, " ({}", display_comma_separated(&self.columns))?;
+            f.write_str(" (")?;
+            NewLine.fmt(f)?;
+            Indent(DisplayCommaSeparated(&self.columns)).fmt(f)?;
             if !self.columns.is_empty() && !self.constraints.is_empty() {
-                write!(f, ", ")?;
+                f.write_str(",")?;
+                SpaceOrNewline.fmt(f)?;
             }
-            write!(f, "{})", display_comma_separated(&self.constraints))?;
+            Indent(DisplayCommaSeparated(&self.constraints)).fmt(f)?;
+            NewLine.fmt(f)?;
+            f.write_str(")")?;
         } else if self.query.is_none() && self.like.is_none() && self.clone.is_none() {
             // PostgreSQL allows `CREATE TABLE t ();`, but requires empty parens
-            write!(f, " ()")?;
+            f.write_str(" ()")?;
         }
 
         // Hive table comment should be after column definitions, please refer to:
         // [Hive](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+DDL#LanguageManualDDL-CreateTable)
-        if let Some(CommentDef::AfterColumnDefsWithoutEq(comment)) = &self.comment {
+        if let Some(comment) = &self.comment {
             write!(f, " COMMENT '{comment}'")?;
         }
 
@@ -332,40 +379,22 @@ impl Display for CreateTable {
             }
             write!(f, " LOCATION '{}'", self.location.as_ref().unwrap())?;
         }
-        if !self.table_properties.is_empty() {
-            write!(
-                f,
-                " TBLPROPERTIES ({})",
-                display_comma_separated(&self.table_properties)
-            )?;
-        }
-        if !self.with_options.is_empty() {
-            write!(f, " WITH ({})", display_comma_separated(&self.with_options))?;
-        }
-        if let Some(engine) = &self.engine {
-            write!(f, " ENGINE={engine}")?;
-        }
-        if let Some(comment_def) = &self.comment {
-            match comment_def {
-                CommentDef::WithEq(comment) => {
-                    write!(f, " COMMENT = '{comment}'")?;
-                }
-                CommentDef::WithoutEq(comment) => {
-                    write!(f, " COMMENT '{comment}'")?;
-                }
-                // For CommentDef::AfterColumnDefsWithoutEq will be displayed after column definition
-                CommentDef::AfterColumnDefsWithoutEq(_) => (),
-            }
+
+        match &self.table_options {
+            options @ CreateTableOptions::With(_)
+            | options @ CreateTableOptions::Plain(_)
+            | options @ CreateTableOptions::TableProperties(_) => write!(f, " {options}")?,
+            _ => (),
         }
 
-        if let Some(auto_increment_offset) = self.auto_increment_offset {
-            write!(f, " AUTO_INCREMENT {auto_increment_offset}")?;
-        }
         if let Some(primary_key) = &self.primary_key {
-            write!(f, " PRIMARY KEY {}", primary_key)?;
+            write!(f, " PRIMARY KEY {primary_key}")?;
         }
         if let Some(order_by) = &self.order_by {
-            write!(f, " ORDER BY {}", order_by)?;
+            write!(f, " ORDER BY {order_by}")?;
+        }
+        if let Some(inherits) = &self.inherits {
+            write!(f, " INHERITS ({})", display_comma_separated(inherits))?;
         }
         if let Some(partition_by) = self.partition_by.as_ref() {
             write!(f, " PARTITION BY {partition_by}")?;
@@ -373,12 +402,31 @@ impl Display for CreateTable {
         if let Some(cluster_by) = self.cluster_by.as_ref() {
             write!(f, " CLUSTER BY {cluster_by}")?;
         }
+        if let options @ CreateTableOptions::Options(_) = &self.table_options {
+            write!(f, " {options}")?;
+        }
+        if let Some(external_volume) = self.external_volume.as_ref() {
+            write!(f, " EXTERNAL_VOLUME = '{external_volume}'")?;
+        }
 
-        if let Some(options) = self.options.as_ref() {
+        if let Some(catalog) = self.catalog.as_ref() {
+            write!(f, " CATALOG = '{catalog}'")?;
+        }
+
+        if self.iceberg {
+            if let Some(base_location) = self.base_location.as_ref() {
+                write!(f, " BASE_LOCATION = '{base_location}'")?;
+            }
+        }
+
+        if let Some(catalog_sync) = self.catalog_sync.as_ref() {
+            write!(f, " CATALOG_SYNC = '{catalog_sync}'")?;
+        }
+
+        if let Some(storage_serialization_policy) = self.storage_serialization_policy.as_ref() {
             write!(
                 f,
-                " OPTIONS({})",
-                display_comma_separated(options.as_slice())
+                " STORAGE_SERIALIZATION_POLICY = {storage_serialization_policy}"
             )?;
         }
 
@@ -432,13 +480,6 @@ impl Display for CreateTable {
             write!(f, " WITH TAG ({})", display_comma_separated(tag.as_slice()))?;
         }
 
-        if let Some(default_charset) = &self.default_charset {
-            write!(f, " DEFAULT CHARSET={default_charset}")?;
-        }
-        if let Some(collation) = &self.collation {
-            write!(f, " COLLATE={collation}")?;
-        }
-
         if self.on_commit.is_some() {
             let on_commit = match self.on_commit {
                 Some(OnCommit::DeleteRows) => "ON COMMIT DELETE ROWS",
@@ -547,28 +588,32 @@ impl Display for Insert {
             )?;
         }
         if !self.columns.is_empty() {
-            write!(f, "({}) ", display_comma_separated(&self.columns))?;
+            write!(f, "({})", display_comma_separated(&self.columns))?;
+            SpaceOrNewline.fmt(f)?;
         }
         if let Some(ref parts) = self.partitioned {
             if !parts.is_empty() {
-                write!(f, "PARTITION ({}) ", display_comma_separated(parts))?;
+                write!(f, "PARTITION ({})", display_comma_separated(parts))?;
+                SpaceOrNewline.fmt(f)?;
             }
         }
         if !self.after_columns.is_empty() {
-            write!(f, "({}) ", display_comma_separated(&self.after_columns))?;
+            write!(f, "({})", display_comma_separated(&self.after_columns))?;
+            SpaceOrNewline.fmt(f)?;
         }
 
         if let Some(settings) = &self.settings {
-            write!(f, "SETTINGS {} ", display_comma_separated(settings))?;
+            write!(f, "SETTINGS {}", display_comma_separated(settings))?;
+            SpaceOrNewline.fmt(f)?;
         }
 
         if let Some(source) = &self.source {
-            write!(f, "{source}")?;
+            source.fmt(f)?;
         } else if !self.assignments.is_empty() {
-            write!(f, "SET ")?;
-            write!(f, "{}", display_comma_separated(&self.assignments))?;
+            write!(f, "SET")?;
+            indented_list(f, &self.assignments)?;
         } else if let Some(format_clause) = &self.format_clause {
-            write!(f, "{format_clause}")?;
+            format_clause.fmt(f)?;
         } else if self.columns.is_empty() {
             write!(f, "DEFAULT VALUES")?;
         }
@@ -588,7 +633,9 @@ impl Display for Insert {
         }
 
         if let Some(returning) = &self.returning {
-            write!(f, " RETURNING {}", display_comma_separated(returning))?;
+            SpaceOrNewline.fmt(f)?;
+            f.write_str("RETURNING")?;
+            indented_list(f, returning)?;
         }
         Ok(())
     }
@@ -617,32 +664,45 @@ pub struct Delete {
 
 impl Display for Delete {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "DELETE ")?;
+        f.write_str("DELETE")?;
         if !self.tables.is_empty() {
-            write!(f, "{} ", display_comma_separated(&self.tables))?;
+            indented_list(f, &self.tables)?;
         }
         match &self.from {
             FromTable::WithFromKeyword(from) => {
-                write!(f, "FROM {}", display_comma_separated(from))?;
+                f.write_str(" FROM")?;
+                indented_list(f, from)?;
             }
             FromTable::WithoutKeyword(from) => {
-                write!(f, "{}", display_comma_separated(from))?;
+                indented_list(f, from)?;
             }
         }
         if let Some(using) = &self.using {
-            write!(f, " USING {}", display_comma_separated(using))?;
+            SpaceOrNewline.fmt(f)?;
+            f.write_str("USING")?;
+            indented_list(f, using)?;
         }
         if let Some(selection) = &self.selection {
-            write!(f, " WHERE {selection}")?;
+            SpaceOrNewline.fmt(f)?;
+            f.write_str("WHERE")?;
+            SpaceOrNewline.fmt(f)?;
+            Indent(selection).fmt(f)?;
         }
         if let Some(returning) = &self.returning {
-            write!(f, " RETURNING {}", display_comma_separated(returning))?;
+            SpaceOrNewline.fmt(f)?;
+            f.write_str("RETURNING")?;
+            indented_list(f, returning)?;
         }
         if !self.order_by.is_empty() {
-            write!(f, " ORDER BY {}", display_comma_separated(&self.order_by))?;
+            SpaceOrNewline.fmt(f)?;
+            f.write_str("ORDER BY")?;
+            indented_list(f, &self.order_by)?;
         }
         if let Some(limit) = &self.limit {
-            write!(f, " LIMIT {limit}")?;
+            SpaceOrNewline.fmt(f)?;
+            f.write_str("LIMIT")?;
+            SpaceOrNewline.fmt(f)?;
+            Indent(limit).fmt(f)?;
         }
         Ok(())
     }

src/ast/helpers/key_value_options.rs

@@ -0,0 +1,89 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+//! Key-value options for SQL statements.
+//! See [this page](https://docs.snowflake.com/en/sql-reference/commands-data-loading) for more details.
+
+#[cfg(not(feature = "std"))]
+use alloc::string::String;
+#[cfg(not(feature = "std"))]
+use alloc::vec::Vec;
+use core::fmt;
+use core::fmt::Formatter;
+
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
+#[cfg(feature = "visitor")]
+use sqlparser_derive::{Visit, VisitMut};
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct KeyValueOptions {
+    pub options: Vec<KeyValueOption>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum KeyValueOptionType {
+    STRING,
+    BOOLEAN,
+    ENUM,
+    NUMBER,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct KeyValueOption {
+    pub option_name: String,
+    pub option_type: KeyValueOptionType,
+    pub value: String,
+}
+
+impl fmt::Display for KeyValueOptions {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        if !self.options.is_empty() {
+            let mut first = false;
+            for option in &self.options {
+                if !first {
+                    first = true;
+                } else {
+                    f.write_str(" ")?;
+                }
+                write!(f, "{option}")?;
+            }
+        }
+        Ok(())
+    }
+}
+
+impl fmt::Display for KeyValueOption {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self.option_type {
+            KeyValueOptionType::STRING => {
+                write!(f, "{}='{}'", self.option_name, self.value)?;
+            }
+            KeyValueOptionType::ENUM | KeyValueOptionType::BOOLEAN | KeyValueOptionType::NUMBER => {
+                write!(f, "{}={}", self.option_name, self.value)?;
+            }
+        }
+        Ok(())
+    }
+}

src/ast/helpers/mod.rs

@@ -15,5 +15,6 @@
 // specific language governing permissions and limitations
 // under the License.
 pub mod attached_token;
+pub mod key_value_options;
 pub mod stmt_create_table;
 pub mod stmt_data_loading;

src/ast/helpers/stmt_create_table.rs

@@ -26,10 +26,12 @@ use sqlparser_derive::{Visit, VisitMut};
 
 use super::super::dml::CreateTable;
 use crate::ast::{
-    ClusteredBy, ColumnDef, CommentDef, Expr, FileFormat, HiveDistributionStyle, HiveFormat, Ident,
-    ObjectName, OnCommit, OneOrManyWithParens, Query, RowAccessPolicy, SqlOption, Statement,
-    TableConstraint, TableEngine, Tag, WrappedCollection,
+    ClusteredBy, ColumnDef, CommentDef, CreateTableOptions, Expr, FileFormat,
+    HiveDistributionStyle, HiveFormat, Ident, ObjectName, OnCommit, OneOrManyWithParens, Query,
+    RowAccessPolicy, Statement, StorageSerializationPolicy, TableConstraint, Tag,
+    WrappedCollection,
 };
+
 use crate::parser::ParserError;
 
 /// Builder for create table statement variant ([1]).
@@ -42,12 +44,11 @@ use crate::parser::ParserError;
 /// ```rust
 /// use sqlparser::ast::helpers::stmt_create_table::CreateTableBuilder;
 /// use sqlparser::ast::{ColumnDef, DataType, Ident, ObjectName};
-/// let builder = CreateTableBuilder::new(ObjectName(vec![Ident::new("table_name")]))
+/// let builder = CreateTableBuilder::new(ObjectName::from(vec![Ident::new("table_name")]))
 ///    .if_not_exists(true)
 ///    .columns(vec![ColumnDef {
 ///        name: Ident::new("c1"),
 ///        data_type: DataType::Int(None),
-///        collation: None,
 ///        options: vec![],
 /// }]);
 /// // You can access internal elements with ease
@@ -71,32 +72,27 @@ pub struct CreateTableBuilder {
     pub if_not_exists: bool,
     pub transient: bool,
     pub volatile: bool,
+    pub iceberg: bool,
     pub name: ObjectName,
     pub columns: Vec<ColumnDef>,
     pub constraints: Vec<TableConstraint>,
     pub hive_distribution: HiveDistributionStyle,
     pub hive_formats: Option<HiveFormat>,
-    pub table_properties: Vec<SqlOption>,
-    pub with_options: Vec<SqlOption>,
     pub file_format: Option<FileFormat>,
     pub location: Option<String>,
     pub query: Option<Box<Query>>,
     pub without_rowid: bool,
     pub like: Option<ObjectName>,
     pub clone: Option<ObjectName>,
-    pub engine: Option<TableEngine>,
     pub comment: Option<CommentDef>,
-    pub auto_increment_offset: Option<u32>,
-    pub default_charset: Option<String>,
-    pub collation: Option<String>,
     pub on_commit: Option<OnCommit>,
     pub on_cluster: Option<Ident>,
     pub primary_key: Option<Box<Expr>>,
     pub order_by: Option<OneOrManyWithParens<Expr>>,
     pub partition_by: Option<Box<Expr>>,
-    pub cluster_by: Option<WrappedCollection<Vec<Ident>>>,
+    pub cluster_by: Option<WrappedCollection<Vec<Expr>>>,
     pub clustered_by: Option<ClusteredBy>,
-    pub options: Option<Vec<SqlOption>>,
+    pub inherits: Option<Vec<ObjectName>>,
     pub strict: bool,
     pub copy_grants: bool,
     pub enable_schema_evolution: Option<bool>,
@@ -107,6 +103,12 @@ pub struct CreateTableBuilder {
     pub with_aggregation_policy: Option<ObjectName>,
     pub with_row_access_policy: Option<RowAccessPolicy>,
     pub with_tags: Option<Vec<Tag>>,
+    pub base_location: Option<String>,
+    pub external_volume: Option<String>,
+    pub catalog: Option<String>,
+    pub catalog_sync: Option<String>,
+    pub storage_serialization_policy: Option<StorageSerializationPolicy>,
+    pub table_options: CreateTableOptions,
 }
 
 impl CreateTableBuilder {
@@ -119,24 +121,19 @@ impl CreateTableBuilder {
             if_not_exists: false,
             transient: false,
             volatile: false,
+            iceberg: false,
             name,
             columns: vec![],
             constraints: vec![],
             hive_distribution: HiveDistributionStyle::NONE,
             hive_formats: None,
-            table_properties: vec![],
-            with_options: vec![],
             file_format: None,
             location: None,
             query: None,
             without_rowid: false,
             like: None,
             clone: None,
-            engine: None,
             comment: None,
-            auto_increment_offset: None,
-            default_charset: None,
-            collation: None,
             on_commit: None,
             on_cluster: None,
             primary_key: None,
@@ -144,7 +141,7 @@ impl CreateTableBuilder {
             partition_by: None,
             cluster_by: None,
             clustered_by: None,
-            options: None,
+            inherits: None,
             strict: false,
             copy_grants: false,
             enable_schema_evolution: None,
@@ -155,6 +152,12 @@ impl CreateTableBuilder {
             with_aggregation_policy: None,
             with_row_access_policy: None,
             with_tags: None,
+            base_location: None,
+            external_volume: None,
+            catalog: None,
+            catalog_sync: None,
+            storage_serialization_policy: None,
+            table_options: CreateTableOptions::None,
         }
     }
     pub fn or_replace(mut self, or_replace: bool) -> Self {
@@ -192,6 +195,11 @@ impl CreateTableBuilder {
         self
     }
 
+    pub fn iceberg(mut self, iceberg: bool) -> Self {
+        self.iceberg = iceberg;
+        self
+    }
+
     pub fn columns(mut self, columns: Vec<ColumnDef>) -> Self {
         self.columns = columns;
         self
@@ -212,15 +220,6 @@ impl CreateTableBuilder {
         self
     }
 
-    pub fn table_properties(mut self, table_properties: Vec<SqlOption>) -> Self {
-        self.table_properties = table_properties;
-        self
-    }
-
-    pub fn with_options(mut self, with_options: Vec<SqlOption>) -> Self {
-        self.with_options = with_options;
-        self
-    }
     pub fn file_format(mut self, file_format: Option<FileFormat>) -> Self {
         self.file_format = file_format;
         self
@@ -250,31 +249,11 @@ impl CreateTableBuilder {
         self
     }
 
-    pub fn engine(mut self, engine: Option<TableEngine>) -> Self {
-        self.engine = engine;
-        self
-    }
-
-    pub fn comment(mut self, comment: Option<CommentDef>) -> Self {
+    pub fn comment_after_column_def(mut self, comment: Option<CommentDef>) -> Self {
         self.comment = comment;
         self
     }
 
-    pub fn auto_increment_offset(mut self, offset: Option<u32>) -> Self {
-        self.auto_increment_offset = offset;
-        self
-    }
-
-    pub fn default_charset(mut self, default_charset: Option<String>) -> Self {
-        self.default_charset = default_charset;
-        self
-    }
-
-    pub fn collation(mut self, collation: Option<String>) -> Self {
-        self.collation = collation;
-        self
-    }
-
     pub fn on_commit(mut self, on_commit: Option<OnCommit>) -> Self {
         self.on_commit = on_commit;
         self
@@ -300,7 +279,7 @@ impl CreateTableBuilder {
         self
     }
 
-    pub fn cluster_by(mut self, cluster_by: Option<WrappedCollection<Vec<Ident>>>) -> Self {
+    pub fn cluster_by(mut self, cluster_by: Option<WrappedCollection<Vec<Expr>>>) -> Self {
         self.cluster_by = cluster_by;
         self
     }
@@ -310,8 +289,8 @@ impl CreateTableBuilder {
         self
     }
 
-    pub fn options(mut self, options: Option<Vec<SqlOption>>) -> Self {
-        self.options = options;
+    pub fn inherits(mut self, inherits: Option<Vec<ObjectName>>) -> Self {
+        self.inherits = inherits;
         self
     }
 
@@ -371,6 +350,39 @@ impl CreateTableBuilder {
         self
     }
 
+    pub fn base_location(mut self, base_location: Option<String>) -> Self {
+        self.base_location = base_location;
+        self
+    }
+
+    pub fn external_volume(mut self, external_volume: Option<String>) -> Self {
+        self.external_volume = external_volume;
+        self
+    }
+
+    pub fn catalog(mut self, catalog: Option<String>) -> Self {
+        self.catalog = catalog;
+        self
+    }
+
+    pub fn catalog_sync(mut self, catalog_sync: Option<String>) -> Self {
+        self.catalog_sync = catalog_sync;
+        self
+    }
+
+    pub fn storage_serialization_policy(
+        mut self,
+        storage_serialization_policy: Option<StorageSerializationPolicy>,
+    ) -> Self {
+        self.storage_serialization_policy = storage_serialization_policy;
+        self
+    }
+
+    pub fn table_options(mut self, table_options: CreateTableOptions) -> Self {
+        self.table_options = table_options;
+        self
+    }
+
     pub fn build(self) -> Statement {
         Statement::CreateTable(CreateTable {
             or_replace: self.or_replace,
@@ -380,24 +392,19 @@ impl CreateTableBuilder {
             if_not_exists: self.if_not_exists,
             transient: self.transient,
             volatile: self.volatile,
+            iceberg: self.iceberg,
             name: self.name,
             columns: self.columns,
             constraints: self.constraints,
             hive_distribution: self.hive_distribution,
             hive_formats: self.hive_formats,
-            table_properties: self.table_properties,
-            with_options: self.with_options,
             file_format: self.file_format,
             location: self.location,
             query: self.query,
             without_rowid: self.without_rowid,
             like: self.like,
             clone: self.clone,
-            engine: self.engine,
             comment: self.comment,
-            auto_increment_offset: self.auto_increment_offset,
-            default_charset: self.default_charset,
-            collation: self.collation,
             on_commit: self.on_commit,
             on_cluster: self.on_cluster,
             primary_key: self.primary_key,
@@ -405,7 +412,7 @@ impl CreateTableBuilder {
             partition_by: self.partition_by,
             cluster_by: self.cluster_by,
             clustered_by: self.clustered_by,
-            options: self.options,
+            inherits: self.inherits,
             strict: self.strict,
             copy_grants: self.copy_grants,
             enable_schema_evolution: self.enable_schema_evolution,
@@ -416,6 +423,12 @@ impl CreateTableBuilder {
             with_aggregation_policy: self.with_aggregation_policy,
             with_row_access_policy: self.with_row_access_policy,
             with_tags: self.with_tags,
+            base_location: self.base_location,
+            external_volume: self.external_volume,
+            catalog: self.catalog,
+            catalog_sync: self.catalog_sync,
+            storage_serialization_policy: self.storage_serialization_policy,
+            table_options: self.table_options,
         })
     }
 }
@@ -435,24 +448,19 @@ impl TryFrom<Statement> for CreateTableBuilder {
                 if_not_exists,
                 transient,
                 volatile,
+                iceberg,
                 name,
                 columns,
                 constraints,
                 hive_distribution,
                 hive_formats,
-                table_properties,
-                with_options,
                 file_format,
                 location,
                 query,
                 without_rowid,
                 like,
                 clone,
-                engine,
                 comment,
-                auto_increment_offset,
-                default_charset,
-                collation,
                 on_commit,
                 on_cluster,
                 primary_key,
@@ -460,7 +468,7 @@ impl TryFrom<Statement> for CreateTableBuilder {
                 partition_by,
                 cluster_by,
                 clustered_by,
-                options,
+                inherits,
                 strict,
                 copy_grants,
                 enable_schema_evolution,
@@ -471,6 +479,12 @@ impl TryFrom<Statement> for CreateTableBuilder {
                 with_aggregation_policy,
                 with_row_access_policy,
                 with_tags,
+                base_location,
+                external_volume,
+                catalog,
+                catalog_sync,
+                storage_serialization_policy,
+                table_options,
             }) => Ok(Self {
                 or_replace,
                 temporary,
@@ -483,19 +497,13 @@ impl TryFrom<Statement> for CreateTableBuilder {
                 constraints,
                 hive_distribution,
                 hive_formats,
-                table_properties,
-                with_options,
                 file_format,
                 location,
                 query,
                 without_rowid,
                 like,
                 clone,
-                engine,
                 comment,
-                auto_increment_offset,
-                default_charset,
-                collation,
                 on_commit,
                 on_cluster,
                 primary_key,
@@ -503,8 +511,9 @@ impl TryFrom<Statement> for CreateTableBuilder {
                 partition_by,
                 cluster_by,
                 clustered_by,
-                options,
+                inherits,
                 strict,
+                iceberg,
                 copy_grants,
                 enable_schema_evolution,
                 change_tracking,
@@ -515,6 +524,12 @@ impl TryFrom<Statement> for CreateTableBuilder {
                 with_row_access_policy,
                 with_tags,
                 volatile,
+                base_location,
+                external_volume,
+                catalog,
+                catalog_sync,
+                storage_serialization_policy,
+                table_options,
             }),
             _ => Err(ParserError::ParserError(format!(
                 "Expected create table statement, but received: {stmt}"
@@ -527,8 +542,9 @@ impl TryFrom<Statement> for CreateTableBuilder {
 #[derive(Default)]
 pub(crate) struct CreateTableConfiguration {
     pub partition_by: Option<Box<Expr>>,
-    pub cluster_by: Option<WrappedCollection<Vec<Ident>>>,
-    pub options: Option<Vec<SqlOption>>,
+    pub cluster_by: Option<WrappedCollection<Vec<Expr>>>,
+    pub inherits: Option<Vec<ObjectName>>,
+    pub table_options: CreateTableOptions,
 }
 
 #[cfg(test)]
@@ -539,7 +555,7 @@ mod tests {
 
     #[test]
     pub fn test_from_valid_statement() {
-        let builder = CreateTableBuilder::new(ObjectName(vec![Ident::new("table_name")]));
+        let builder = CreateTableBuilder::new(ObjectName::from(vec![Ident::new("table_name")]));
 
         let stmt = builder.clone().build();
 

src/ast/helpers/stmt_data_loading.rs

@@ -21,15 +21,13 @@
 
 #[cfg(not(feature = "std"))]
 use alloc::string::String;
-#[cfg(not(feature = "std"))]
-use alloc::vec::Vec;
 use core::fmt;
-use core::fmt::Formatter;
 
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
-use crate::ast::{Ident, ObjectName};
+use crate::ast::helpers::key_value_options::KeyValueOptions;
+use crate::ast::{Ident, ObjectName, SelectItem};
 #[cfg(feature = "visitor")]
 use sqlparser_derive::{Visit, VisitMut};
 
@@ -38,35 +36,29 @@ use sqlparser_derive::{Visit, VisitMut};
 #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
 pub struct StageParamsObject {
     pub url: Option<String>,
-    pub encryption: DataLoadingOptions,
+    pub encryption: KeyValueOptions,
     pub endpoint: Option<String>,
     pub storage_integration: Option<String>,
-    pub credentials: DataLoadingOptions,
+    pub credentials: KeyValueOptions,
 }
 
+/// This enum enables support for both standard SQL select item expressions
+/// and Snowflake-specific ones for data loading.
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
-pub struct DataLoadingOptions {
-    pub options: Vec<DataLoadingOption>,
+pub enum StageLoadSelectItemKind {
+    SelectItem(SelectItem),
+    StageLoadSelectItem(StageLoadSelectItem),
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
-pub enum DataLoadingOptionType {
-    STRING,
-    BOOLEAN,
-    ENUM,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
-pub struct DataLoadingOption {
-    pub option_name: String,
-    pub option_type: DataLoadingOptionType,
-    pub value: String,
+impl fmt::Display for StageLoadSelectItemKind {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match &self {
+            StageLoadSelectItemKind::SelectItem(item) => write!(f, "{item}"),
+            StageLoadSelectItemKind::StageLoadSelectItem(item) => write!(f, "{item}"),
+        }
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
@@ -105,42 +97,6 @@ impl fmt::Display for StageParamsObject {
     }
 }
 
-impl fmt::Display for DataLoadingOptions {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        if !self.options.is_empty() {
-            let mut first = false;
-            for option in &self.options {
-                if !first {
-                    first = true;
-                } else {
-                    f.write_str(" ")?;
-                }
-                write!(f, "{}", option)?;
-            }
-        }
-        Ok(())
-    }
-}
-
-impl fmt::Display for DataLoadingOption {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self.option_type {
-            DataLoadingOptionType::STRING => {
-                write!(f, "{}='{}'", self.option_name, self.value)?;
-            }
-            DataLoadingOptionType::ENUM => {
-                // single quote is omitted
-                write!(f, "{}={}", self.option_name, self.value)?;
-            }
-            DataLoadingOptionType::BOOLEAN => {
-                // single quote is omitted
-                write!(f, "{}={}", self.option_name, self.value)?;
-            }
-        }
-        Ok(())
-    }
-}
-
 impl fmt::Display for StageLoadSelectItem {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         if self.alias.is_some() {

src/ast/operator.rs

@@ -53,6 +53,21 @@ pub enum UnaryOperator {
     PGAbs,
     /// Unary logical not operator: e.g. `! false` (Hive-specific)
     BangNot,
+    /// `#` Number of points in path or polygon (PostgreSQL/Redshift geometric operator)
+    /// see <https://www.postgresql.org/docs/9.5/functions-geometry.html>
+    Hash,
+    /// `@-@` Length or circumference (PostgreSQL/Redshift geometric operator)
+    /// see <https://www.postgresql.org/docs/9.5/functions-geometry.html>
+    AtDashAt,
+    /// `@@` Center (PostgreSQL/Redshift geometric operator)
+    /// see <https://www.postgresql.org/docs/9.5/functions-geometry.html>
+    DoubleAt,
+    /// `?-` Is horizontal? (PostgreSQL/Redshift geometric operator)
+    /// see <https://www.postgresql.org/docs/9.5/functions-geometry.html>
+    QuestionDash,
+    /// `?|` Is vertical? (PostgreSQL/Redshift geometric operator)
+    /// see <https://www.postgresql.org/docs/9.5/functions-geometry.html>
+    QuestionPipe,
 }
 
 impl fmt::Display for UnaryOperator {
@@ -68,6 +83,11 @@ impl fmt::Display for UnaryOperator {
             UnaryOperator::PGPrefixFactorial => "!!",
             UnaryOperator::PGAbs => "@",
             UnaryOperator::BangNot => "!",
+            UnaryOperator::Hash => "#",
+            UnaryOperator::AtDashAt => "@-@",
+            UnaryOperator::DoubleAt => "@@",
+            UnaryOperator::QuestionDash => "?-",
+            UnaryOperator::QuestionPipe => "?|",
         })
     }
 }
@@ -119,6 +139,11 @@ pub enum BinaryOperator {
     DuckIntegerDivide,
     /// MySQL [`DIV`](https://dev.mysql.com/doc/refman/8.0/en/arithmetic-functions.html) integer division
     MyIntegerDivide,
+    /// MATCH operator, e.g. `a MATCH b` (SQLite-specific)
+    /// See <https://www.sqlite.org/lang_expr.html#the_like_glob_regexp_match_and_extract_operators>
+    Match,
+    /// REGEXP operator, e.g. `a REGEXP b` (SQLite-specific)
+    Regexp,
     /// Support for custom operators (such as Postgres custom operators)
     Custom(String),
     /// Bitwise XOR, e.g. `a # b` (PostgreSQL-specific)
@@ -253,6 +278,57 @@ pub enum BinaryOperator {
     /// Specifies a test for an overlap between two datetime periods:
     /// <https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#overlaps-predicate>
     Overlaps,
+    /// `##` Point of closest proximity (PostgreSQL/Redshift geometric operator)
+    /// See <https://www.postgresql.org/docs/9.5/functions-geometry.html>
+    DoubleHash,
+    /// `<->` Distance between (PostgreSQL/Redshift geometric operator)
+    /// See <https://www.postgresql.org/docs/9.5/functions-geometry.html>
+    LtDashGt,
+    /// `&<` Overlaps to left? (PostgreSQL/Redshift geometric operator)
+    /// See <https://www.postgresql.org/docs/9.5/functions-geometry.html>
+    AndLt,
+    /// `&>` Overlaps to right? (PostgreSQL/Redshift geometric operator)
+    /// See <https://www.postgresql.org/docs/9.5/functions-geometry.html>
+    AndGt,
+    /// `<<|` Is strictly below? (PostgreSQL/Redshift geometric operator)
+    /// See <https://www.postgresql.org/docs/9.5/functions-geometry.html>
+    LtLtPipe,
+    /// `|>>` Is strictly above? (PostgreSQL/Redshift geometric operator)
+    /// See <https://www.postgresql.org/docs/9.5/functions-geometry.html>
+    PipeGtGt,
+    /// `&<|` Does not extend above? (PostgreSQL/Redshift geometric operator)
+    /// See <https://www.postgresql.org/docs/9.5/functions-geometry.html>
+    AndLtPipe,
+    /// `|&>` Does not extend below? (PostgreSQL/Redshift geometric operator)
+    /// See <https://www.postgresql.org/docs/9.5/functions-geometry.html>
+    PipeAndGt,
+    /// `<^` Is below? (PostgreSQL/Redshift geometric operator)
+    /// See <https://www.postgresql.org/docs/9.5/functions-geometry.html>
+    LtCaret,
+    /// `>^` Is above? (PostgreSQL/Redshift geometric operator)
+    /// See <https://www.postgresql.org/docs/9.5/functions-geometry.html>
+    GtCaret,
+    /// `?#` Intersects? (PostgreSQL/Redshift geometric operator)
+    /// See <https://www.postgresql.org/docs/9.5/functions-geometry.html>
+    QuestionHash,
+    /// `?-` Is horizontal? (PostgreSQL/Redshift geometric operator)
+    /// See <https://www.postgresql.org/docs/9.5/functions-geometry.html>
+    QuestionDash,
+    /// `?-|` Is perpendicular? (PostgreSQL/Redshift geometric operator)
+    /// See <https://www.postgresql.org/docs/9.5/functions-geometry.html>
+    QuestionDashPipe,
+    /// `?||` Are Parallel? (PostgreSQL/Redshift geometric operator)
+    /// See <https://www.postgresql.org/docs/9.5/functions-geometry.html>
+    QuestionDoublePipe,
+    /// `@` Contained or on? (PostgreSQL/Redshift geometric operator)
+    /// See <https://www.postgresql.org/docs/9.5/functions-geometry.html>
+    At,
+    /// `~=` Same as? (PostgreSQL/Redshift geometric operator)
+    /// See <https://www.postgresql.org/docs/9.5/functions-geometry.html>
+    TildeEq,
+    /// ':=' Assignment Operator
+    /// See <https://dev.mysql.com/doc/refman/8.4/en/assignment-operators.html#operator_assign-value>
+    Assignment,
 }
 
 impl fmt::Display for BinaryOperator {
@@ -279,6 +355,8 @@ impl fmt::Display for BinaryOperator {
             BinaryOperator::BitwiseXor => f.write_str("^"),
             BinaryOperator::DuckIntegerDivide => f.write_str("//"),
             BinaryOperator::MyIntegerDivide => f.write_str("DIV"),
+            BinaryOperator::Match => f.write_str("MATCH"),
+            BinaryOperator::Regexp => f.write_str("REGEXP"),
             BinaryOperator::Custom(s) => f.write_str(s),
             BinaryOperator::PGBitwiseXor => f.write_str("#"),
             BinaryOperator::PGBitwiseShiftLeft => f.write_str("<<"),
@@ -310,6 +388,23 @@ impl fmt::Display for BinaryOperator {
                 write!(f, "OPERATOR({})", display_separated(idents, "."))
             }
             BinaryOperator::Overlaps => f.write_str("OVERLAPS"),
+            BinaryOperator::DoubleHash => f.write_str("##"),
+            BinaryOperator::LtDashGt => f.write_str("<->"),
+            BinaryOperator::AndLt => f.write_str("&<"),
+            BinaryOperator::AndGt => f.write_str("&>"),
+            BinaryOperator::LtLtPipe => f.write_str("<<|"),
+            BinaryOperator::PipeGtGt => f.write_str("|>>"),
+            BinaryOperator::AndLtPipe => f.write_str("&<|"),
+            BinaryOperator::PipeAndGt => f.write_str("|&>"),
+            BinaryOperator::LtCaret => f.write_str("<^"),
+            BinaryOperator::GtCaret => f.write_str(">^"),
+            BinaryOperator::QuestionHash => f.write_str("?#"),
+            BinaryOperator::QuestionDash => f.write_str("?-"),
+            BinaryOperator::QuestionDashPipe => f.write_str("?-|"),
+            BinaryOperator::QuestionDoublePipe => f.write_str("?||"),
+            BinaryOperator::At => f.write_str("@"),
+            BinaryOperator::TildeEq => f.write_str("~="),
+            BinaryOperator::Assignment => f.write_str(":="),
         }
     }
 }

src/ast/spans.rs

@@ -15,26 +15,30 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use crate::ast::{query::SelectItemQualifiedWildcardKind, ColumnOptions};
 use core::iter;
 
 use crate::tokenizer::Span;
 
 use super::{
-    dcl::SecondaryRoles, AccessExpr, AlterColumnOperation, AlterIndexOperation,
-    AlterTableOperation, Array, Assignment, AssignmentTarget, CloseCursor, ClusteredIndex,
-    ColumnDef, ColumnOption, ColumnOptionDef, ConflictTarget, ConnectBy, ConstraintCharacteristics,
-    CopySource, CreateIndex, CreateTable, CreateTableOptions, Cte, Delete, DoUpdate,
-    ExceptSelectItem, ExcludeSelectItem, Expr, ExprWithAlias, Fetch, FromTable, Function,
-    FunctionArg, FunctionArgExpr, FunctionArgumentClause, FunctionArgumentList, FunctionArguments,
-    GroupByExpr, HavingBound, IlikeSelectItem, Insert, Interpolate, InterpolateExpr, Join,
-    JoinConstraint, JoinOperator, JsonPath, JsonPathElem, LateralView, MatchRecognizePattern,
-    Measure, NamedWindowDefinition, ObjectName, Offset, OnConflict, OnConflictAction, OnInsert,
-    OrderBy, OrderByExpr, Partition, PivotValueSource, ProjectionSelect, Query, ReferentialAction,
+    dcl::SecondaryRoles, value::ValueWithSpan, AccessExpr, AlterColumnOperation,
+    AlterIndexOperation, AlterTableOperation, Array, Assignment, AssignmentTarget, AttachedToken,
+    BeginEndStatements, CaseStatement, CloseCursor, ClusteredIndex, ColumnDef, ColumnOption,
+    ColumnOptionDef, ConditionalStatementBlock, ConditionalStatements, ConflictTarget, ConnectBy,
+    ConstraintCharacteristics, CopySource, CreateIndex, CreateTable, CreateTableOptions, Cte,
+    Delete, DoUpdate, ExceptSelectItem, ExcludeSelectItem, Expr, ExprWithAlias, Fetch, FromTable,
+    Function, FunctionArg, FunctionArgExpr, FunctionArgumentClause, FunctionArgumentList,
+    FunctionArguments, GroupByExpr, HavingBound, IfStatement, IlikeSelectItem, IndexColumn, Insert,
+    Interpolate, InterpolateExpr, Join, JoinConstraint, JoinOperator, JsonPath, JsonPathElem,
+    LateralView, LimitClause, MatchRecognizePattern, Measure, NamedParenthesizedList,
+    NamedWindowDefinition, ObjectName, ObjectNamePart, Offset, OnConflict, OnConflictAction,
+    OnInsert, OpenStatement, OrderBy, OrderByExpr, OrderByKind, Partition, PivotValueSource,
+    ProjectionSelect, Query, RaiseStatement, RaiseStatementValue, ReferentialAction,
     RenameSelectItem, ReplaceSelectElement, ReplaceSelectItem, Select, SelectInto, SelectItem,
     SetExpr, SqlOption, Statement, Subscript, SymbolDefinition, TableAlias, TableAliasColumnDef,
     TableConstraint, TableFactor, TableObject, TableOptionsClustered, TableWithJoins,
-    UpdateTableFromKind, Use, Value, Values, ViewColumnDef, WildcardAdditionalOptions, With,
-    WithFill,
+    UpdateTableFromKind, Use, Value, Values, ViewColumnDef, WhileStatement,
+    WildcardAdditionalOptions, With, WithFill,
 };
 
 /// Given an iterator of spans, return the [Span::union] of all spans.
@@ -93,14 +97,13 @@ impl Spanned for Query {
             with,
             body,
             order_by,
-            limit,
-            limit_by,
-            offset,
+            limit_clause,
             fetch,
-            locks: _,         // todo
-            for_clause: _,    // todo, mssql specific
-            settings: _,      // todo, clickhouse specific
-            format_clause: _, // todo, clickhouse specific
+            locks: _,          // todo
+            for_clause: _,     // todo, mssql specific
+            settings: _,       // todo, clickhouse specific
+            format_clause: _,  // todo, clickhouse specific
+            pipe_operators: _, // todo bigquery specific
         } = self;
 
         union_spans(
@@ -108,14 +111,31 @@ impl Spanned for Query {
                 .map(|i| i.span())
                 .chain(core::iter::once(body.span()))
                 .chain(order_by.as_ref().map(|i| i.span()))
-                .chain(limit.as_ref().map(|i| i.span()))
-                .chain(limit_by.iter().map(|i| i.span()))
-                .chain(offset.as_ref().map(|i| i.span()))
+                .chain(limit_clause.as_ref().map(|i| i.span()))
                 .chain(fetch.as_ref().map(|i| i.span())),
         )
     }
 }
 
+impl Spanned for LimitClause {
+    fn span(&self) -> Span {
+        match self {
+            LimitClause::LimitOffset {
+                limit,
+                offset,
+                limit_by,
+            } => union_spans(
+                limit
+                    .iter()
+                    .map(|i| i.span())
+                    .chain(offset.as_ref().map(|i| i.span()))
+                    .chain(limit_by.iter().map(|i| i.span())),
+            ),
+            LimitClause::OffsetCommaLimit { offset, limit } => offset.span().union(&limit.span()),
+        }
+    }
+}
+
 impl Spanned for Offset {
     fn span(&self) -> Span {
         let Offset {
@@ -190,6 +210,7 @@ impl Spanned for SetExpr {
             SetExpr::Insert(statement) => statement.span(),
             SetExpr::Table(_) => Span::empty(),
             SetExpr::Update(statement) => statement.span(),
+            SetExpr::Delete(statement) => statement.span(),
         }
     }
 }
@@ -214,6 +235,7 @@ impl Spanned for Values {
 /// - [Statement::CopyIntoSnowflake]
 /// - [Statement::CreateSecret]
 /// - [Statement::CreateRole]
+/// - [Statement::AlterType]
 /// - [Statement::AlterRole]
 /// - [Statement::AttachDatabase]
 /// - [Statement::AttachDuckDBDatabase]
@@ -227,11 +249,7 @@ impl Spanned for Values {
 /// - [Statement::Fetch]
 /// - [Statement::Flush]
 /// - [Statement::Discard]
-/// - [Statement::SetRole]
-/// - [Statement::SetVariable]
-/// - [Statement::SetTimeZone]
-/// - [Statement::SetNames]
-/// - [Statement::SetNamesDefault]
+/// - [Statement::Set]
 /// - [Statement::ShowFunctions]
 /// - [Statement::ShowVariable]
 /// - [Statement::ShowStatus]
@@ -241,7 +259,6 @@ impl Spanned for Values {
 /// - [Statement::ShowTables]
 /// - [Statement::ShowCollation]
 /// - [Statement::StartTransaction]
-/// - [Statement::SetTransaction]
 /// - [Statement::Comment]
 /// - [Statement::Commit]
 /// - [Statement::Rollback]
@@ -295,7 +312,6 @@ impl Spanned for Statement {
                 table_names,
                 partitions,
                 table: _,
-                only: _,
                 identity: _,
                 cascade: _,
                 on_cluster: _,
@@ -321,6 +337,10 @@ impl Spanned for Statement {
                 file_format: _,
                 source,
             } => source.span(),
+            Statement::Case(stmt) => stmt.span(),
+            Statement::If(stmt) => stmt.span(),
+            Statement::While(stmt) => stmt.span(),
+            Statement::Raise(stmt) => stmt.span(),
             Statement::Call(function) => function.span(),
             Statement::Copy {
                 source,
@@ -332,8 +352,9 @@ impl Spanned for Statement {
             } => source.span(),
             Statement::CopyIntoSnowflake {
                 into: _,
-                from_stage: _,
-                from_stage_alias: _,
+                into_columns: _,
+                from_obj: _,
+                from_obj_alias: _,
                 stage_params: _,
                 from_transformations: _,
                 files: _,
@@ -341,7 +362,11 @@ impl Spanned for Statement {
                 file_format: _,
                 copy_options: _,
                 validation_mode: _,
+                kind: _,
+                from_query: _,
+                partition: _,
             } => Span::empty(),
+            Statement::Open(open) => open.span(),
             Statement::Close { cursor } => match cursor {
                 CloseCursor::All => Span::empty(),
                 CloseCursor::Specific { name } => name.span,
@@ -362,6 +387,7 @@ impl Spanned for Statement {
             ),
             Statement::Delete(delete) => delete.span(),
             Statement::CreateView {
+                or_alter: _,
                 or_replace: _,
                 materialized: _,
                 name,
@@ -397,6 +423,8 @@ impl Spanned for Statement {
             Statement::CreateIndex(create_index) => create_index.span(),
             Statement::CreateRole { .. } => Span::empty(),
             Statement::CreateSecret { .. } => Span::empty(),
+            Statement::CreateServer { .. } => Span::empty(),
+            Statement::CreateConnector { .. } => Span::empty(),
             Statement::AlterTable {
                 name,
                 if_exists: _,
@@ -404,6 +432,7 @@ impl Spanned for Statement {
                 operations,
                 location: _,
                 on_cluster,
+                iceberg: _,
             } => union_spans(
                 core::iter::once(name.span())
                     .chain(operations.iter().map(|i| i.span()))
@@ -422,12 +451,15 @@ impl Spanned for Statement {
                     .chain(with_options.iter().map(|i| i.span())),
             ),
             // These statements need to be implemented
+            Statement::AlterType { .. } => Span::empty(),
             Statement::AlterRole { .. } => Span::empty(),
+            Statement::AlterSession { .. } => Span::empty(),
             Statement::AttachDatabase { .. } => Span::empty(),
             Statement::AttachDuckDBDatabase { .. } => Span::empty(),
             Statement::DetachDuckDBDatabase { .. } => Span::empty(),
             Statement::Drop { .. } => Span::empty(),
             Statement::DropFunction { .. } => Span::empty(),
+            Statement::DropDomain { .. } => Span::empty(),
             Statement::DropProcedure { .. } => Span::empty(),
             Statement::DropSecret { .. } => Span::empty(),
             Statement::Declare { .. } => Span::empty(),
@@ -436,11 +468,7 @@ impl Spanned for Statement {
             Statement::Fetch { .. } => Span::empty(),
             Statement::Flush { .. } => Span::empty(),
             Statement::Discard { .. } => Span::empty(),
-            Statement::SetRole { .. } => Span::empty(),
-            Statement::SetVariable { .. } => Span::empty(),
-            Statement::SetTimeZone { .. } => Span::empty(),
-            Statement::SetNames { .. } => Span::empty(),
-            Statement::SetNamesDefault {} => Span::empty(),
+            Statement::Set(_) => Span::empty(),
             Statement::ShowFunctions { .. } => Span::empty(),
             Statement::ShowVariable { .. } => Span::empty(),
             Statement::ShowStatus { .. } => Span::empty(),
@@ -451,13 +479,13 @@ impl Spanned for Statement {
             Statement::ShowCollation { .. } => Span::empty(),
             Statement::Use(u) => u.span(),
             Statement::StartTransaction { .. } => Span::empty(),
-            Statement::SetTransaction { .. } => Span::empty(),
             Statement::Comment { .. } => Span::empty(),
             Statement::Commit { .. } => Span::empty(),
             Statement::Rollback { .. } => Span::empty(),
             Statement::CreateSchema { .. } => Span::empty(),
             Statement::CreateDatabase { .. } => Span::empty(),
             Statement::CreateFunction { .. } => Span::empty(),
+            Statement::CreateDomain { .. } => Span::empty(),
             Statement::CreateTrigger { .. } => Span::empty(),
             Statement::DropTrigger { .. } => Span::empty(),
             Statement::CreateProcedure { .. } => Span::empty(),
@@ -465,6 +493,7 @@ impl Spanned for Statement {
             Statement::CreateStage { .. } => Span::empty(),
             Statement::Assert { .. } => Span::empty(),
             Statement::Grant { .. } => Span::empty(),
+            Statement::Deny { .. } => Span::empty(),
             Statement::Revoke { .. } => Span::empty(),
             Statement::Deallocate { .. } => Span::empty(),
             Statement::Execute { .. } => Span::empty(),
@@ -486,9 +515,12 @@ impl Spanned for Statement {
             Statement::OptimizeTable { .. } => Span::empty(),
             Statement::CreatePolicy { .. } => Span::empty(),
             Statement::AlterPolicy { .. } => Span::empty(),
+            Statement::AlterConnector { .. } => Span::empty(),
             Statement::DropPolicy { .. } => Span::empty(),
+            Statement::DropConnector { .. } => Span::empty(),
             Statement::ShowDatabases { .. } => Span::empty(),
             Statement::ShowSchemas { .. } => Span::empty(),
+            Statement::ShowObjects { .. } => Span::empty(),
             Statement::ShowViews { .. } => Span::empty(),
             Statement::LISTEN { .. } => Span::empty(),
             Statement::NOTIFY { .. } => Span::empty(),
@@ -496,8 +528,9 @@ impl Spanned for Statement {
             Statement::UNLISTEN { .. } => Span::empty(),
             Statement::RenameTable { .. } => Span::empty(),
             Statement::RaisError { .. } => Span::empty(),
+            Statement::Print { .. } => Span::empty(),
+            Statement::Return { .. } => Span::empty(),
             Statement::List(..) | Statement::Remove(..) => Span::empty(),
-            Statement::SetSessionParam { .. } => Span::empty(),
         }
     }
 }
@@ -532,32 +565,27 @@ impl Spanned for CreateTable {
             if_not_exists: _, // bool
             transient: _,     // bool
             volatile: _,      // bool
+            iceberg: _,       // bool, Snowflake specific
             name,
             columns,
             constraints,
             hive_distribution: _, // hive specific
             hive_formats: _,      // hive specific
-            table_properties,
-            with_options,
-            file_format: _, // enum
-            location: _,    // string, no span
+            file_format: _,       // enum
+            location: _,          // string, no span
             query,
             without_rowid: _, // bool
             like,
             clone,
-            engine: _,                          // todo
-            comment: _,                         // todo, no span
-            auto_increment_offset: _,           // u32, no span
-            default_charset: _,                 // string, no span
-            collation: _,                       // string, no span
-            on_commit: _,                       // enum
+            comment: _, // todo, no span
+            on_commit: _,
             on_cluster: _,                      // todo, clickhouse specific
             primary_key: _,                     // todo, clickhouse specific
             order_by: _,                        // todo, clickhouse specific
             partition_by: _,                    // todo, BigQuery specific
             cluster_by: _,                      // todo, BigQuery specific
             clustered_by: _,                    // todo, Hive specific
-            options: _,                         // todo, BigQuery specific
+            inherits: _,                        // todo, PostgreSQL specific
             strict: _,                          // bool
             copy_grants: _,                     // bool
             enable_schema_evolution: _,         // bool
@@ -568,14 +596,19 @@ impl Spanned for CreateTable {
             with_aggregation_policy: _,         // todo, Snowflake specific
             with_row_access_policy: _,          // todo, Snowflake specific
             with_tags: _,                       // todo, Snowflake specific
+            external_volume: _,                 // todo, Snowflake specific
+            base_location: _,                   // todo, Snowflake specific
+            catalog: _,                         // todo, Snowflake specific
+            catalog_sync: _,                    // todo, Snowflake specific
+            storage_serialization_policy: _,
+            table_options,
         } = self;
 
         union_spans(
             core::iter::once(name.span())
+                .chain(core::iter::once(table_options.span()))
                 .chain(columns.iter().map(|i| i.span()))
                 .chain(constraints.iter().map(|i| i.span()))
-                .chain(table_properties.iter().map(|i| i.span()))
-                .chain(with_options.iter().map(|i| i.span()))
                 .chain(query.iter().map(|i| i.span()))
                 .chain(like.iter().map(|i| i.span()))
                 .chain(clone.iter().map(|i| i.span())),
@@ -588,15 +621,10 @@ impl Spanned for ColumnDef {
         let ColumnDef {
             name,
             data_type: _, // enum
-            collation,
             options,
         } = self;
 
-        union_spans(
-            core::iter::once(name.span)
-                .chain(collation.iter().map(|i| i.span()))
-                .chain(options.iter().map(|i| i.span())),
-        )
+        union_spans(core::iter::once(name.span).chain(options.iter().map(|i| i.span())))
     }
 }
 
@@ -624,7 +652,7 @@ impl Spanned for TableConstraint {
                 name.iter()
                     .map(|i| i.span)
                     .chain(index_name.iter().map(|i| i.span))
-                    .chain(columns.iter().map(|i| i.span))
+                    .chain(columns.iter().map(|i| i.span()))
                     .chain(characteristics.iter().map(|i| i.span())),
             ),
             TableConstraint::PrimaryKey {
@@ -638,12 +666,13 @@ impl Spanned for TableConstraint {
                 name.iter()
                     .map(|i| i.span)
                     .chain(index_name.iter().map(|i| i.span))
-                    .chain(columns.iter().map(|i| i.span))
+                    .chain(columns.iter().map(|i| i.span()))
                     .chain(characteristics.iter().map(|i| i.span())),
             ),
             TableConstraint::ForeignKey {
                 name,
                 columns,
+                index_name,
                 foreign_table,
                 referred_columns,
                 on_delete,
@@ -652,6 +681,7 @@ impl Spanned for TableConstraint {
             } => union_spans(
                 name.iter()
                     .map(|i| i.span)
+                    .chain(index_name.iter().map(|i| i.span))
                     .chain(columns.iter().map(|i| i.span))
                     .chain(core::iter::once(foreign_table.span()))
                     .chain(referred_columns.iter().map(|i| i.span))
@@ -659,9 +689,11 @@ impl Spanned for TableConstraint {
                     .chain(on_update.iter().map(|i| i.span()))
                     .chain(characteristics.iter().map(|i| i.span())),
             ),
-            TableConstraint::Check { name, expr } => {
-                expr.span().union_opt(&name.as_ref().map(|i| i.span))
-            }
+            TableConstraint::Check {
+                name,
+                expr,
+                enforced: _,
+            } => expr.span().union_opt(&name.as_ref().map(|i| i.span)),
             TableConstraint::Index {
                 display_as_key: _,
                 name,
@@ -670,7 +702,7 @@ impl Spanned for TableConstraint {
             } => union_spans(
                 name.iter()
                     .map(|i| i.span)
-                    .chain(columns.iter().map(|i| i.span)),
+                    .chain(columns.iter().map(|i| i.span())),
             ),
             TableConstraint::FulltextOrSpatial {
                 fulltext: _,
@@ -681,7 +713,7 @@ impl Spanned for TableConstraint {
                 opt_index_name
                     .iter()
                     .map(|i| i.span)
-                    .chain(columns.iter().map(|i| i.span)),
+                    .chain(columns.iter().map(|i| i.span())),
             ),
         }
     }
@@ -692,7 +724,7 @@ impl Spanned for CreateIndex {
         let CreateIndex {
             name,
             table_name,
-            using,
+            using: _,
             columns,
             unique: _,        // bool
             concurrently: _,  // bool
@@ -707,8 +739,7 @@ impl Spanned for CreateIndex {
             name.iter()
                 .map(|i| i.span())
                 .chain(core::iter::once(table_name.span()))
-                .chain(using.iter().map(|i| i.span))
-                .chain(columns.iter().map(|i| i.span()))
+                .chain(columns.iter().map(|i| i.column.span()))
                 .chain(include.iter().map(|i| i.span))
                 .chain(with.iter().map(|i| i.span()))
                 .chain(predicate.iter().map(|i| i.span())),
@@ -716,6 +747,98 @@ impl Spanned for CreateIndex {
     }
 }
 
+impl Spanned for IndexColumn {
+    fn span(&self) -> Span {
+        self.column.span()
+    }
+}
+
+impl Spanned for CaseStatement {
+    fn span(&self) -> Span {
+        let CaseStatement {
+            case_token: AttachedToken(start),
+            match_expr: _,
+            when_blocks: _,
+            else_block: _,
+            end_case_token: AttachedToken(end),
+        } = self;
+
+        union_spans([start.span, end.span].into_iter())
+    }
+}
+
+impl Spanned for IfStatement {
+    fn span(&self) -> Span {
+        let IfStatement {
+            if_block,
+            elseif_blocks,
+            else_block,
+            end_token,
+        } = self;
+
+        union_spans(
+            iter::once(if_block.span())
+                .chain(elseif_blocks.iter().map(|b| b.span()))
+                .chain(else_block.as_ref().map(|b| b.span()))
+                .chain(end_token.as_ref().map(|AttachedToken(t)| t.span)),
+        )
+    }
+}
+
+impl Spanned for WhileStatement {
+    fn span(&self) -> Span {
+        let WhileStatement { while_block } = self;
+
+        while_block.span()
+    }
+}
+
+impl Spanned for ConditionalStatements {
+    fn span(&self) -> Span {
+        match self {
+            ConditionalStatements::Sequence { statements } => {
+                union_spans(statements.iter().map(|s| s.span()))
+            }
+            ConditionalStatements::BeginEnd(bes) => bes.span(),
+        }
+    }
+}
+
+impl Spanned for ConditionalStatementBlock {
+    fn span(&self) -> Span {
+        let ConditionalStatementBlock {
+            start_token: AttachedToken(start_token),
+            condition,
+            then_token,
+            conditional_statements,
+        } = self;
+
+        union_spans(
+            iter::once(start_token.span)
+                .chain(condition.as_ref().map(|c| c.span()))
+                .chain(then_token.as_ref().map(|AttachedToken(t)| t.span))
+                .chain(iter::once(conditional_statements.span())),
+        )
+    }
+}
+
+impl Spanned for RaiseStatement {
+    fn span(&self) -> Span {
+        let RaiseStatement { value } = self;
+
+        union_spans(value.iter().map(|value| value.span()))
+    }
+}
+
+impl Spanned for RaiseStatementValue {
+    fn span(&self) -> Span {
+        match self {
+            RaiseStatementValue::UsingMessage(expr) => expr.span(),
+            RaiseStatementValue::Expr(expr) => expr.span(),
+        }
+    }
+}
+
 /// # partial span
 ///
 /// Missing spans:
@@ -751,6 +874,7 @@ impl Spanned for ColumnOption {
             ColumnOption::Check(expr) => expr.span(),
             ColumnOption::DialectSpecific(_) => Span::empty(),
             ColumnOption::CharacterSet(object_name) => object_name.span(),
+            ColumnOption::Collation(object_name) => object_name.span(),
             ColumnOption::Comment(_) => Span::empty(),
             ColumnOption::OnUpdate(expr) => expr.span(),
             ColumnOption::Generated { .. } => Span::empty(),
@@ -759,6 +883,7 @@ impl Spanned for ColumnOption {
             ColumnOption::OnConflict(..) => Span::empty(),
             ColumnOption::Policy(..) => Span::empty(),
             ColumnOption::Tags(..) => Span::empty(),
+            ColumnOption::Srid(..) => Span::empty(),
         }
     }
 }
@@ -800,6 +925,7 @@ impl Spanned for AlterColumnOperation {
             AlterColumnOperation::SetDataType {
                 data_type: _,
                 using,
+                had_set: _,
             } => using.as_ref().map_or(Span::empty(), |u| u.span()),
             AlterColumnOperation::AddGenerated { .. } => Span::empty(),
         }
@@ -867,10 +993,13 @@ impl Spanned for ViewColumnDef {
             options,
         } = self;
 
-        union_spans(
-            core::iter::once(name.span)
-                .chain(options.iter().flat_map(|i| i.iter().map(|k| k.span()))),
-        )
+        name.span.union_opt(&options.as_ref().map(|o| o.span()))
+    }
+}
+
+impl Spanned for ColumnOptions {
+    fn span(&self) -> Span {
+        union_spans(self.as_slice().iter().map(|i| i.span()))
     }
 }
 
@@ -887,6 +1016,14 @@ impl Spanned for SqlOption {
             } => union_spans(
                 core::iter::once(column_name.span).chain(for_values.iter().map(|i| i.span())),
             ),
+            SqlOption::TableSpace(_) => Span::empty(),
+            SqlOption::Comment(_) => Span::empty(),
+            SqlOption::NamedParenthesizedList(NamedParenthesizedList {
+                key: name,
+                name: value,
+                values,
+            }) => union_spans(core::iter::once(name.span).chain(values.iter().map(|i| i.span)))
+                .union_opt(&value.as_ref().map(|i| i.span)),
         }
     }
 }
@@ -923,7 +1060,11 @@ impl Spanned for CreateTableOptions {
         match self {
             CreateTableOptions::None => Span::empty(),
             CreateTableOptions::With(vec) => union_spans(vec.iter().map(|i| i.span())),
-            CreateTableOptions::Options(vec) => union_spans(vec.iter().map(|i| i.span())),
+            CreateTableOptions::Options(vec) => {
+                union_spans(vec.as_slice().iter().map(|i| i.span()))
+            }
+            CreateTableOptions::Plain(vec) => union_spans(vec.iter().map(|i| i.span())),
+            CreateTableOptions::TableProperties(vec) => union_spans(vec.iter().map(|i| i.span())),
         }
     }
 }
@@ -935,7 +1076,10 @@ impl Spanned for CreateTableOptions {
 impl Spanned for AlterTableOperation {
     fn span(&self) -> Span {
         match self {
-            AlterTableOperation::AddConstraint(table_constraint) => table_constraint.span(),
+            AlterTableOperation::AddConstraint {
+                constraint,
+                not_valid: _,
+            } => constraint.span(),
             AlterTableOperation::AddColumn {
                 column_keyword: _,
                 if_not_exists: _,
@@ -967,10 +1111,11 @@ impl Spanned for AlterTableOperation {
                 drop_behavior: _,
             } => name.span,
             AlterTableOperation::DropColumn {
-                column_name,
+                has_column_keyword: _,
+                column_names,
                 if_exists: _,
                 drop_behavior: _,
-            } => column_name.span,
+            } => union_spans(column_names.iter().map(|i| i.span)),
             AlterTableOperation::AttachPartition { partition } => partition.span(),
             AlterTableOperation::DetachPartition { partition } => partition.span(),
             AlterTableOperation::FreezePartition {
@@ -986,6 +1131,8 @@ impl Spanned for AlterTableOperation {
                 .span()
                 .union_opt(&with_name.as_ref().map(|n| n.span)),
             AlterTableOperation::DropPrimaryKey => Span::empty(),
+            AlterTableOperation::DropForeignKey { name } => name.span,
+            AlterTableOperation::DropIndex { name } => name.span,
             AlterTableOperation::EnableAlwaysRule { name } => name.span,
             AlterTableOperation::EnableAlwaysTrigger { name } => name.span,
             AlterTableOperation::EnableReplicaRule { name } => name.span,
@@ -1049,6 +1196,11 @@ impl Spanned for AlterTableOperation {
             AlterTableOperation::DropClusteringKey => Span::empty(),
             AlterTableOperation::SuspendRecluster => Span::empty(),
             AlterTableOperation::ResumeRecluster => Span::empty(),
+            AlterTableOperation::Algorithm { .. } => Span::empty(),
+            AlterTableOperation::AutoIncrement { value, .. } => value.span(),
+            AlterTableOperation::Lock { .. } => Span::empty(),
+            AlterTableOperation::ReplicaIdentity { .. } => Span::empty(),
+            AlterTableOperation::ValidateConstraint { name } => name.span,
         }
     }
 }
@@ -1082,16 +1234,21 @@ impl Spanned for ProjectionSelect {
     }
 }
 
+/// # partial span
+///
+/// Missing spans:
+/// - [OrderByKind::All]
 impl Spanned for OrderBy {
     fn span(&self) -> Span {
-        let OrderBy { exprs, interpolate } = self;
-
-        union_spans(
-            exprs
-                .iter()
-                .map(|i| i.span())
-                .chain(interpolate.iter().map(|i| i.span())),
-        )
+        match &self.kind {
+            OrderByKind::All(_) => Span::empty(),
+            OrderByKind::Expressions(exprs) => union_spans(
+                exprs
+                    .iter()
+                    .map(|i| i.span())
+                    .chain(self.interpolate.iter().map(|i| i.span())),
+            ),
+        }
     }
 }
 
@@ -1259,7 +1416,6 @@ impl Spanned for AssignmentTarget {
 /// f.e. `IS NULL <expr>` reports as `<expr>::span`.
 ///
 /// Missing spans:
-/// - [Expr::TypedString]
 /// - [Expr::MatchAgainst] # MySQL specific
 /// - [Expr::RLike] # MySQL specific
 /// - [Expr::Struct] # BigQuery specific
@@ -1272,7 +1428,6 @@ impl Spanned for Expr {
         match self {
             Expr::Identifier(ident) => ident.span,
             Expr::CompoundIdentifier(vec) => union_spans(vec.iter().map(|i| i.span)),
-            Expr::CompositeAccess { expr, key } => expr.span().union(&key.span),
             Expr::CompoundFieldAccess { root, access_chain } => {
                 union_spans(iter::once(root.span()).chain(access_chain.iter().map(|i| i.span())))
             }
@@ -1352,10 +1507,10 @@ impl Spanned for Expr {
                 .union_opt(&overlay_for.as_ref().map(|i| i.span())),
             Expr::Collate { expr, collation } => expr
                 .span()
-                .union(&union_spans(collation.0.iter().map(|i| i.span))),
+                .union(&union_spans(collation.0.iter().map(|i| i.span()))),
             Expr::Nested(expr) => expr.span(),
             Expr::Value(value) => value.span(),
-            Expr::TypedString { .. } => Span::empty(),
+            Expr::TypedString { value, .. } => value.span(),
             Expr::Function(function) => function.span(),
             Expr::GroupingSets(vec) => {
                 union_spans(vec.iter().flat_map(|i| i.iter().map(|k| k.span())))
@@ -1410,6 +1565,7 @@ impl Spanned for Expr {
                 substring_from,
                 substring_for,
                 special: _,
+                shorthand: _,
             } => union_spans(
                 core::iter::once(expr.span())
                     .chain(substring_from.as_ref().map(|i| i.span()))
@@ -1429,20 +1585,26 @@ impl Spanned for Expr {
                             .map(|items| union_spans(items.iter().map(|i| i.span()))),
                     ),
             ),
-            Expr::IntroducedString { value, .. } => value.span(),
+            Expr::Prefixed { value, .. } => value.span(),
             Expr::Case {
+                case_token,
+                end_token,
                 operand,
                 conditions,
-                results,
                 else_result,
             } => union_spans(
-                operand
-                    .as_ref()
-                    .map(|i| i.span())
-                    .into_iter()
-                    .chain(conditions.iter().map(|i| i.span()))
-                    .chain(results.iter().map(|i| i.span()))
-                    .chain(else_result.as_ref().map(|i| i.span())),
+                iter::once(case_token.0.span)
+                    .chain(
+                        operand
+                            .as_ref()
+                            .map(|i| i.span())
+                            .into_iter()
+                            .chain(conditions.iter().flat_map(|case_when| {
+                                [case_when.condition.span(), case_when.result.span()]
+                            }))
+                            .chain(else_result.as_ref().map(|i| i.span())),
+                    )
+                    .chain(iter::once(end_token.0.span)),
             ),
             Expr::Exists { subquery, .. } => subquery.span(),
             Expr::Subquery(query) => query.span(),
@@ -1456,13 +1618,13 @@ impl Spanned for Expr {
                 object_name
                     .0
                     .iter()
-                    .map(|i| i.span)
+                    .map(|i| i.span())
                     .chain(iter::once(token.0.span)),
             ),
             Expr::OuterJoin(expr) => expr.span(),
             Expr::Prior(expr) => expr.span(),
             Expr::Lambda(_) => Span::empty(),
-            Expr::Method(_) => Span::empty(),
+            Expr::MemberOf(member_of) => member_of.value.span().union(&member_of.array.span()),
         }
     }
 }
@@ -1501,7 +1663,15 @@ impl Spanned for ObjectName {
     fn span(&self) -> Span {
         let ObjectName(segments) = self;
 
-        union_spans(segments.iter().map(|i| i.span))
+        union_spans(segments.iter().map(|i| i.span()))
+    }
+}
+
+impl Spanned for ObjectNamePart {
+    fn span(&self) -> Span {
+        match self {
+            ObjectNamePart::Identifier(ident) => ident.span,
+        }
     }
 }
 
@@ -1532,7 +1702,7 @@ impl Spanned for Function {
         union_spans(
             name.0
                 .iter()
-                .map(|i| i.span)
+                .map(|i| i.span())
                 .chain(iter::once(args.span()))
                 .chain(iter::once(parameters.span()))
                 .chain(filter.iter().map(|i| i.span()))
@@ -1609,16 +1779,23 @@ impl Spanned for JsonPathElem {
     }
 }
 
+impl Spanned for SelectItemQualifiedWildcardKind {
+    fn span(&self) -> Span {
+        match self {
+            SelectItemQualifiedWildcardKind::ObjectName(object_name) => object_name.span(),
+            SelectItemQualifiedWildcardKind::Expr(expr) => expr.span(),
+        }
+    }
+}
+
 impl Spanned for SelectItem {
     fn span(&self) -> Span {
         match self {
             SelectItem::UnnamedExpr(expr) => expr.span(),
             SelectItem::ExprWithAlias { expr, alias } => expr.span().union(&alias.span),
-            SelectItem::QualifiedWildcard(object_name, wildcard_additional_options) => union_spans(
-                object_name
-                    .0
-                    .iter()
-                    .map(|i| i.span)
+            SelectItem::QualifiedWildcard(kind, wildcard_additional_options) => union_spans(
+                [kind.span()]
+                    .into_iter()
                     .chain(iter::once(wildcard_additional_options.span())),
             ),
             SelectItem::Wildcard(wildcard_additional_options) => wildcard_additional_options.span(),
@@ -1725,10 +1902,11 @@ impl Spanned for TableFactor {
                 partitions: _,
                 json_path: _,
                 sample: _,
+                index_hints: _,
             } => union_spans(
                 name.0
                     .iter()
-                    .map(|i| i.span)
+                    .map(|i| i.span())
                     .chain(alias.as_ref().map(|alias| {
                         union_spans(
                             iter::once(alias.name.span)
@@ -1773,11 +1951,12 @@ impl Spanned for TableFactor {
             } => union_spans(
                 name.0
                     .iter()
-                    .map(|i| i.span)
+                    .map(|i| i.span())
                     .chain(args.iter().map(|i| i.span()))
                     .chain(alias.as_ref().map(|alias| alias.span())),
             ),
             TableFactor::JsonTable { .. } => Span::empty(),
+            TableFactor::XmlTable { .. } => Span::empty(),
             TableFactor::Pivot {
                 table,
                 aggregate_functions,
@@ -1796,6 +1975,7 @@ impl Spanned for TableFactor {
             TableFactor::Unpivot {
                 table,
                 value,
+                null_inclusion: _,
                 name,
                 columns,
                 alias,
@@ -1875,8 +2055,7 @@ impl Spanned for OrderByExpr {
     fn span(&self) -> Span {
         let OrderByExpr {
             expr,
-            asc: _,         // bool
-            nulls_first: _, // bool
+            options: _,
             with_fill,
         } = self;
 
@@ -1924,7 +2103,7 @@ impl Spanned for FunctionArgExpr {
         match self {
             FunctionArgExpr::Expr(expr) => expr.span(),
             FunctionArgExpr::QualifiedWildcard(object_name) => {
-                union_spans(object_name.0.iter().map(|i| i.span))
+                union_spans(object_name.0.iter().map(|i| i.span()))
             }
             FunctionArgExpr::Wildcard => Span::empty(),
         }
@@ -1947,10 +2126,13 @@ impl Spanned for TableAliasColumnDef {
     }
 }
 
-/// # missing span
-///
-/// The span of a `Value` is currently not implemented, as doing so
-/// requires a breaking changes, which may be done in a future release.
+impl Spanned for ValueWithSpan {
+    fn span(&self) -> Span {
+        self.span
+    }
+}
+
+/// The span is stored in the `ValueWrapper` struct
 impl Spanned for Value {
     fn span(&self) -> Span {
         Span::empty() // # todo: Value needs to store spans before this is possible
@@ -1978,8 +2160,11 @@ impl Spanned for Join {
 impl Spanned for JoinOperator {
     fn span(&self) -> Span {
         match self {
+            JoinOperator::Join(join_constraint) => join_constraint.span(),
             JoinOperator::Inner(join_constraint) => join_constraint.span(),
+            JoinOperator::Left(join_constraint) => join_constraint.span(),
             JoinOperator::LeftOuter(join_constraint) => join_constraint.span(),
+            JoinOperator::Right(join_constraint) => join_constraint.span(),
             JoinOperator::RightOuter(join_constraint) => join_constraint.span(),
             JoinOperator::FullOuter(join_constraint) => join_constraint.span(),
             JoinOperator::CrossJoin => Span::empty(),
@@ -1995,6 +2180,7 @@ impl Spanned for JoinOperator {
             } => match_condition.span().union(&constraint.span()),
             JoinOperator::Anti(join_constraint) => join_constraint.span(),
             JoinOperator::Semi(join_constraint) => join_constraint.span(),
+            JoinOperator::StraightJoin(join_constraint) => join_constraint.span(),
         }
     }
 }
@@ -2046,6 +2232,7 @@ impl Spanned for Select {
             value_table_mode: _,      // todo, BigQuery specific
             connect_by,
             top_before_distinct: _,
+            flavor: _,
         } = self;
 
         union_spans(
@@ -2124,10 +2311,11 @@ impl Spanned for SelectInto {
 
 impl Spanned for UpdateTableFromKind {
     fn span(&self) -> Span {
-        match self {
-            UpdateTableFromKind::BeforeSet(from) => from.span(),
-            UpdateTableFromKind::AfterSet(from) => from.span(),
-        }
+        let from = match self {
+            UpdateTableFromKind::BeforeSet(from) => from,
+            UpdateTableFromKind::AfterSet(from) => from,
+        };
+        union_spans(from.iter().map(|t| t.span()))
     }
 }
 
@@ -2135,13 +2323,35 @@ impl Spanned for TableObject {
     fn span(&self) -> Span {
         match self {
             TableObject::TableName(ObjectName(segments)) => {
-                union_spans(segments.iter().map(|i| i.span))
+                union_spans(segments.iter().map(|i| i.span()))
             }
             TableObject::TableFunction(func) => func.span(),
         }
     }
 }
 
+impl Spanned for BeginEndStatements {
+    fn span(&self) -> Span {
+        let BeginEndStatements {
+            begin_token,
+            statements,
+            end_token,
+        } = self;
+        union_spans(
+            core::iter::once(begin_token.0.span)
+                .chain(statements.iter().map(|i| i.span()))
+                .chain(core::iter::once(end_token.0.span)),
+        )
+    }
+}
+
+impl Spanned for OpenStatement {
+    fn span(&self) -> Span {
+        let OpenStatement { cursor_name } = self;
+        cursor_name.span
+    }
+}
+
 #[cfg(test)]
 pub mod tests {
     use crate::dialect::{Dialect, GenericDialect, SnowflakeDialect};
@@ -2281,4 +2491,16 @@ pub mod tests {
 
         assert_eq!(test.get_source(body_span), "SELECT cte.* FROM cte");
     }
+
+    #[test]
+    fn test_case_expr_span() {
+        let dialect = &GenericDialect;
+        let mut test = SpanTest::new(dialect, "CASE 1 WHEN 2 THEN 3 ELSE 4 END");
+        let expr = test.0.parse_expr().unwrap();
+        let expr_span = expr.span();
+        assert_eq!(
+            test.get_source(expr_span),
+            "CASE 1 WHEN 2 THEN 3 ELSE 4 END"
+        );
+    }
 }

src/ast/trigger.rs

@@ -110,6 +110,7 @@ impl fmt::Display for TriggerEvent {
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
 pub enum TriggerPeriod {
+    For,
     After,
     Before,
     InsteadOf,
@@ -118,6 +119,7 @@ pub enum TriggerPeriod {
 impl fmt::Display for TriggerPeriod {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
+            TriggerPeriod::For => write!(f, "FOR"),
             TriggerPeriod::After => write!(f, "AFTER"),
             TriggerPeriod::Before => write!(f, "BEFORE"),
             TriggerPeriod::InsteadOf => write!(f, "INSTEAD OF"),

src/ast/value.rs

@@ -26,14 +26,96 @@ use bigdecimal::BigDecimal;
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
-use crate::ast::Ident;
+use crate::{ast::Ident, tokenizer::Span};
 #[cfg(feature = "visitor")]
 use sqlparser_derive::{Visit, VisitMut};
 
+/// Wraps a primitive SQL [`Value`]  with its [`Span`] location
+///
+/// # Example: create a `ValueWithSpan` from a `Value`
+/// ```
+/// # use sqlparser::ast::{Value, ValueWithSpan};
+/// # use sqlparser::tokenizer::{Location, Span};
+/// let value = Value::SingleQuotedString(String::from("endpoint"));
+/// // from line 1, column 1 to line 1, column 7
+/// let span = Span::new(Location::new(1, 1), Location::new(1, 7));
+/// let value_with_span = value.with_span(span);
+/// ```
+///
+/// # Example: create a `ValueWithSpan` from a `Value` with an empty span
+///
+/// You can call [`Value::with_empty_span`] to create a `ValueWithSpan` with an empty span
+/// ```
+/// # use sqlparser::ast::{Value, ValueWithSpan};
+/// # use sqlparser::tokenizer::{Location, Span};
+/// let value = Value::SingleQuotedString(String::from("endpoint"));
+/// let value_with_span = value.with_empty_span();
+/// assert_eq!(value_with_span.span, Span::empty());
+/// ```
+///
+/// You can also use the [`From`] trait to convert  `ValueWithSpan` to/from `Value`s
+/// ```
+/// # use sqlparser::ast::{Value, ValueWithSpan};
+/// # use sqlparser::tokenizer::{Location, Span};
+/// let value = Value::SingleQuotedString(String::from("endpoint"));
+/// // converting `Value` to `ValueWithSpan` results in an empty span
+/// let value_with_span: ValueWithSpan = value.into();
+/// assert_eq!(value_with_span.span, Span::empty());
+/// // convert back to `Value`
+/// let value: Value = value_with_span.into();
+/// ```
+#[derive(Debug, Clone, Eq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct ValueWithSpan {
+    pub value: Value,
+    pub span: Span,
+}
+
+impl PartialEq for ValueWithSpan {
+    fn eq(&self, other: &Self) -> bool {
+        self.value == other.value
+    }
+}
+
+impl Ord for ValueWithSpan {
+    fn cmp(&self, other: &Self) -> core::cmp::Ordering {
+        self.value.cmp(&other.value)
+    }
+}
+
+impl PartialOrd for ValueWithSpan {
+    fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
+        Some(Ord::cmp(self, other))
+    }
+}
+
+impl core::hash::Hash for ValueWithSpan {
+    fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
+        self.value.hash(state);
+    }
+}
+
+impl From<Value> for ValueWithSpan {
+    fn from(value: Value) -> Self {
+        value.with_empty_span()
+    }
+}
+
+impl From<ValueWithSpan> for Value {
+    fn from(value: ValueWithSpan) -> Self {
+        value.value
+    }
+}
+
 /// Primitive SQL values such as number and string
 #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+#[cfg_attr(
+    feature = "visitor",
+    derive(Visit, VisitMut),
+    visit(with = "visit_value")
+)]
 pub enum Value {
     /// Numeric literal
     #[cfg(not(feature = "bigdecimal"))]
@@ -97,6 +179,53 @@ pub enum Value {
     Placeholder(String),
 }
 
+impl ValueWithSpan {
+    /// If the underlying literal is a string, regardless of quote style, returns the associated string value
+    pub fn into_string(self) -> Option<String> {
+        self.value.into_string()
+    }
+}
+
+impl Value {
+    /// If the underlying literal is a string, regardless of quote style, returns the associated string value
+    pub fn into_string(self) -> Option<String> {
+        match self {
+            Value::SingleQuotedString(s)
+            | Value::DoubleQuotedString(s)
+            | Value::TripleSingleQuotedString(s)
+            | Value::TripleDoubleQuotedString(s)
+            | Value::SingleQuotedByteStringLiteral(s)
+            | Value::DoubleQuotedByteStringLiteral(s)
+            | Value::TripleSingleQuotedByteStringLiteral(s)
+            | Value::TripleDoubleQuotedByteStringLiteral(s)
+            | Value::SingleQuotedRawStringLiteral(s)
+            | Value::DoubleQuotedRawStringLiteral(s)
+            | Value::TripleSingleQuotedRawStringLiteral(s)
+            | Value::TripleDoubleQuotedRawStringLiteral(s)
+            | Value::EscapedStringLiteral(s)
+            | Value::UnicodeStringLiteral(s)
+            | Value::NationalStringLiteral(s)
+            | Value::HexStringLiteral(s) => Some(s),
+            Value::DollarQuotedString(s) => Some(s.value),
+            _ => None,
+        }
+    }
+
+    pub fn with_span(self, span: Span) -> ValueWithSpan {
+        ValueWithSpan { value: self, span }
+    }
+
+    pub fn with_empty_span(self) -> ValueWithSpan {
+        self.with_span(Span::empty())
+    }
+}
+
+impl fmt::Display for ValueWithSpan {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.value)
+    }
+}
+
 impl fmt::Display for Value {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
@@ -326,30 +455,38 @@ impl fmt::Display for EscapeQuotedString<'_> {
         // | `"A\"B\"A"`    | default   | `DoubleQuotedString(String::from("A\"B\"A"))`      | `"A""B""A"`  |
         let quote = self.quote;
         let mut previous_char = char::default();
-        let mut peekable_chars = self.string.chars().peekable();
-        while let Some(&ch) = peekable_chars.peek() {
+        let mut start_idx = 0;
+        let mut peekable_chars = self.string.char_indices().peekable();
+        while let Some(&(idx, ch)) = peekable_chars.peek() {
             match ch {
                 char if char == quote => {
                     if previous_char == '\\' {
-                        write!(f, "{char}")?;
+                        // the quote is already escaped with a backslash, skip
                         peekable_chars.next();
                         continue;
                     }
                     peekable_chars.next();
-                    if peekable_chars.peek().map(|c| *c == quote).unwrap_or(false) {
-                        write!(f, "{char}{char}")?;
-                        peekable_chars.next();
-                    } else {
-                        write!(f, "{char}{char}")?;
+                    match peekable_chars.peek() {
+                        Some((_, c)) if *c == quote => {
+                            // the quote is already escaped with another quote, skip
+                            peekable_chars.next();
+                        }
+                        _ => {
+                            // The quote is not escaped.
+                            // Including idx in the range, so the quote at idx will be printed twice:
+                            // in this call to write_str() and in the next one.
+                            f.write_str(&self.string[start_idx..=idx])?;
+                            start_idx = idx;
+                        }
                     }
                 }
                 _ => {
-                    write!(f, "{ch}")?;
                     peekable_chars.next();
                 }
             }
             previous_char = ch;
         }
+        f.write_str(&self.string[start_idx..])?;
         Ok(())
     }
 }
@@ -413,16 +550,16 @@ impl fmt::Display for EscapeUnicodeStringLiteral<'_> {
                     write!(f, r#"\\"#)?;
                 }
                 x if x.is_ascii() => {
-                    write!(f, "{}", c)?;
+                    write!(f, "{c}")?;
                 }
                 _ => {
                     let codepoint = c as u32;
                     // if the character fits in 32 bits, we can use the \XXXX format
                     // otherwise, we need to use the \+XXXXXX format
                     if codepoint <= 0xFFFF {
-                        write!(f, "\\{:04X}", codepoint)?;
+                        write!(f, "\\{codepoint:04X}")?;
                     } else {
-                        write!(f, "\\+{:06X}", codepoint)?;
+                        write!(f, "\\+{codepoint:06X}")?;
                     }
                 }
             }

src/ast/visitor.rs

@@ -17,7 +17,7 @@
 
 //! Recursive visitors for ast Nodes. See [`Visitor`] for more details.
 
-use crate::ast::{Expr, ObjectName, Query, Statement, TableFactor};
+use crate::ast::{Expr, ObjectName, Query, Statement, TableFactor, Value};
 use core::ops::ControlFlow;
 
 /// A type that can be visited by a [`Visitor`]. See [`Visitor`] for
@@ -233,6 +233,16 @@ pub trait Visitor {
     fn post_visit_statement(&mut self, _statement: &Statement) -> ControlFlow<Self::Break> {
         ControlFlow::Continue(())
     }
+
+    /// Invoked for any Value that appear in the AST before visiting children
+    fn pre_visit_value(&mut self, _value: &Value) -> ControlFlow<Self::Break> {
+        ControlFlow::Continue(())
+    }
+
+    /// Invoked for any Value that appear in the AST after visiting children
+    fn post_visit_value(&mut self, _value: &Value) -> ControlFlow<Self::Break> {
+        ControlFlow::Continue(())
+    }
 }
 
 /// A visitor that can be used to mutate an AST tree.
@@ -337,6 +347,16 @@ pub trait VisitorMut {
     fn post_visit_statement(&mut self, _statement: &mut Statement) -> ControlFlow<Self::Break> {
         ControlFlow::Continue(())
     }
+
+    /// Invoked for any value that appear in the AST before visiting children
+    fn pre_visit_value(&mut self, _value: &mut Value) -> ControlFlow<Self::Break> {
+        ControlFlow::Continue(())
+    }
+
+    /// Invoked for any statements that appear in the AST after visiting children
+    fn post_visit_value(&mut self, _value: &mut Value) -> ControlFlow<Self::Break> {
+        ControlFlow::Continue(())
+    }
 }
 
 struct RelationVisitor<F>(F);
@@ -403,7 +423,7 @@ where
 /// ```
 /// # use sqlparser::parser::Parser;
 /// # use sqlparser::dialect::GenericDialect;
-/// # use sqlparser::ast::{ObjectName, visit_relations_mut};
+/// # use sqlparser::ast::{ObjectName, ObjectNamePart, Ident, visit_relations_mut};
 /// # use core::ops::ControlFlow;
 /// let sql = "SELECT a FROM foo";
 /// let mut statements = Parser::parse_sql(&GenericDialect{}, sql)
@@ -411,7 +431,7 @@ where
 ///
 /// // visit statements, renaming table foo to bar
 /// visit_relations_mut(&mut statements, |table| {
-///   table.0[0].value = table.0[0].value.replace("foo", "bar");
+///   table.0[0] = ObjectNamePart::Identifier(Ident::new("bar"));
 ///   ControlFlow::<()>::Continue(())
 /// });
 ///
@@ -503,7 +523,7 @@ where
 /// // Remove all select limits in sub-queries
 /// visit_expressions_mut(&mut statements, |expr| {
 ///   if let Expr::Subquery(q) = expr {
-///      q.limit = None
+///      q.limit_clause = None;
 ///   }
 ///   ControlFlow::<()>::Continue(())
 /// });
@@ -527,9 +547,9 @@ where
 ///
 /// visit_expressions_mut(&mut statements, |expr| {
 ///   if matches!(expr, Expr::Identifier(col_name) if col_name.value == "x") {
-///     let old_expr = std::mem::replace(expr, Expr::Value(Value::Null));
+///     let old_expr = std::mem::replace(expr, Expr::value(Value::Null));
 ///     *expr = Expr::Function(Function {
-///           name: ObjectName(vec![Ident::new("f")]),
+///           name: ObjectName::from(vec![Ident::new("f")]),
 ///           uses_odbc_syntax: false,
 ///           args: FunctionArguments::List(FunctionArgumentList {
 ///               duplicate_treatment: None,
@@ -627,7 +647,7 @@ where
 /// // Remove all select limits in outer statements (not in sub-queries)
 /// visit_statements_mut(&mut statements, |stmt| {
 ///   if let Statement::Query(q) = stmt {
-///      q.limit = None
+///      q.limit_clause = None;
 ///   }
 ///   ControlFlow::<()>::Continue(())
 /// });
@@ -647,6 +667,7 @@ where
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::ast::Statement;
     use crate::dialect::GenericDialect;
     use crate::parser::Parser;
     use crate::tokenizer::Tokenizer;
@@ -720,7 +741,7 @@ mod tests {
         }
     }
 
-    fn do_visit(sql: &str) -> Vec<String> {
+    fn do_visit<V: Visitor<Break = ()>>(sql: &str, visitor: &mut V) -> Statement {
         let dialect = GenericDialect {};
         let tokens = Tokenizer::new(&dialect, sql).tokenize().unwrap();
         let s = Parser::new(&dialect)
@@ -728,9 +749,9 @@ mod tests {
             .parse_statement()
             .unwrap();
 
-        let mut visitor = TestVisitor::default();
-        s.visit(&mut visitor);
-        visitor.visited
+        let flow = s.visit(visitor);
+        assert_eq!(flow, ControlFlow::Continue(()));
+        s
     }
 
     #[test]
@@ -889,8 +910,9 @@ mod tests {
             ),
         ];
         for (sql, expected) in tests {
-            let actual = do_visit(sql);
-            let actual: Vec<_> = actual.iter().map(|x| x.as_str()).collect();
+            let mut visitor = TestVisitor::default();
+            let _ = do_visit(sql, &mut visitor);
+            let actual: Vec<_> = visitor.visited.iter().map(|x| x.as_str()).collect();
             assert_eq!(actual, expected)
         }
     }
@@ -904,10 +926,10 @@ mod tests {
     #[test]
     fn overflow() {
         let cond = (0..1000)
-            .map(|n| format!("X = {}", n))
+            .map(|n| format!("X = {n}"))
             .collect::<Vec<_>>()
             .join(" OR ");
-        let sql = format!("SELECT x where {0}", cond);
+        let sql = format!("SELECT x where {cond}");
 
         let dialect = GenericDialect {};
         let tokens = Tokenizer::new(&dialect, sql.as_str()).tokenize().unwrap();
@@ -917,6 +939,72 @@ mod tests {
             .unwrap();
 
         let mut visitor = QuickVisitor {};
-        s.visit(&mut visitor);
+        let flow = s.visit(&mut visitor);
+        assert_eq!(flow, ControlFlow::Continue(()));
+    }
+}
+
+#[cfg(test)]
+mod visit_mut_tests {
+    use crate::ast::{Statement, Value, VisitMut, VisitorMut};
+    use crate::dialect::GenericDialect;
+    use crate::parser::Parser;
+    use crate::tokenizer::Tokenizer;
+    use core::ops::ControlFlow;
+
+    #[derive(Default)]
+    struct MutatorVisitor {
+        index: u64,
+    }
+
+    impl VisitorMut for MutatorVisitor {
+        type Break = ();
+
+        fn pre_visit_value(&mut self, value: &mut Value) -> ControlFlow<Self::Break> {
+            self.index += 1;
+            *value = Value::SingleQuotedString(format!("REDACTED_{}", self.index));
+            ControlFlow::Continue(())
+        }
+
+        fn post_visit_value(&mut self, _value: &mut Value) -> ControlFlow<Self::Break> {
+            ControlFlow::Continue(())
+        }
+    }
+
+    fn do_visit_mut<V: VisitorMut<Break = ()>>(sql: &str, visitor: &mut V) -> Statement {
+        let dialect = GenericDialect {};
+        let tokens = Tokenizer::new(&dialect, sql).tokenize().unwrap();
+        let mut s = Parser::new(&dialect)
+            .with_tokens(tokens)
+            .parse_statement()
+            .unwrap();
+
+        let flow = s.visit(visitor);
+        assert_eq!(flow, ControlFlow::Continue(()));
+        s
+    }
+
+    #[test]
+    fn test_value_redact() {
+        let tests = vec![
+            (
+                concat!(
+                    "SELECT * FROM monthly_sales ",
+                    "PIVOT(SUM(a.amount) FOR a.MONTH IN ('JAN', 'FEB', 'MAR', 'APR')) AS p (c, d) ",
+                    "ORDER BY EMPID"
+                ),
+                concat!(
+                    "SELECT * FROM monthly_sales ",
+                    "PIVOT(SUM(a.amount) FOR a.MONTH IN ('REDACTED_1', 'REDACTED_2', 'REDACTED_3', 'REDACTED_4')) AS p (c, d) ",
+                    "ORDER BY EMPID"
+                ),
+            ),
+        ];
+
+        for (sql, expected) in tests {
+            let mut visitor = MutatorVisitor::default();
+            let mutated = do_visit_mut(sql, &mut visitor);
+            assert_eq!(mutated.to_string(), expected)
+        }
     }
 }

src/dialect/bigquery.rs

@@ -15,14 +15,45 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use crate::ast::Statement;
 use crate::dialect::Dialect;
+use crate::keywords::Keyword;
+use crate::parser::{Parser, ParserError};
+
+/// These keywords are disallowed as column identifiers. Such that
+/// `SELECT 5 AS <col> FROM T` is rejected by BigQuery.
+const RESERVED_FOR_COLUMN_ALIAS: &[Keyword] = &[
+    Keyword::WITH,
+    Keyword::SELECT,
+    Keyword::WHERE,
+    Keyword::GROUP,
+    Keyword::HAVING,
+    Keyword::ORDER,
+    Keyword::LATERAL,
+    Keyword::LIMIT,
+    Keyword::FETCH,
+    Keyword::UNION,
+    Keyword::EXCEPT,
+    Keyword::INTERSECT,
+    Keyword::FROM,
+    Keyword::INTO,
+    Keyword::END,
+];
 
 /// A [`Dialect`] for [Google Bigquery](https://cloud.google.com/bigquery/)
 #[derive(Debug, Default)]
 pub struct BigQueryDialect;
 
 impl Dialect for BigQueryDialect {
-    // See https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#identifiers
+    fn parse_statement(&self, parser: &mut Parser) -> Option<Result<Statement, ParserError>> {
+        if parser.parse_keyword(Keyword::BEGIN) {
+            return Some(parser.parse_begin_exception_end());
+        }
+
+        None
+    }
+
+    /// See <https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#identifiers>
     fn is_delimited_identifier_start(&self, ch: char) -> bool {
         ch == '`'
     }
@@ -31,8 +62,16 @@ impl Dialect for BigQueryDialect {
         true
     }
 
+    /// See <https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language#create_table_statement>
+    fn supports_column_definition_trailing_commas(&self) -> bool {
+        true
+    }
+
     fn is_identifier_start(&self, ch: char) -> bool {
         ch.is_ascii_lowercase() || ch.is_ascii_uppercase() || ch == '_'
+            // BigQuery supports `@@foo.bar` variable syntax in its procedural language.
+            // https://cloud.google.com/bigquery/docs/reference/standard-sql/procedural-language#beginexceptionend
+            || ch == '@'
     }
 
     fn is_identifier_part(&self, ch: char) -> bool {
@@ -78,8 +117,31 @@ impl Dialect for BigQueryDialect {
         true
     }
 
+    /// See <https://cloud.google.com/bigquery/docs/reference/standard-sql/query-syntax#select_expression_star>
+    fn supports_select_expr_star(&self) -> bool {
+        true
+    }
+
+    /// See <https://cloud.google.com/bigquery/docs/reference/standard-sql/procedural-language#execute_immediate>
+    fn supports_execute_immediate(&self) -> bool {
+        true
+    }
+
     // See <https://cloud.google.com/bigquery/docs/access-historical-data>
     fn supports_timestamp_versioning(&self) -> bool {
         true
     }
+
+    // See <https://cloud.google.com/bigquery/docs/reference/standard-sql/query-syntax#group_by_clause>
+    fn supports_group_by_expr(&self) -> bool {
+        true
+    }
+
+    fn is_column_alias(&self, kw: &Keyword, _parser: &mut Parser) -> bool {
+        !RESERVED_FOR_COLUMN_ALIAS.contains(kw)
+    }
+
+    fn supports_pipe_operator(&self) -> bool {
+        true
+    }
 }

src/dialect/clickhouse.rs

@@ -59,6 +59,10 @@ impl Dialect for ClickHouseDialect {
         true
     }
 
+    fn supports_numeric_literal_underscores(&self) -> bool {
+        true
+    }
+
     // ClickHouse uses this for some FORMAT expressions in `INSERT` context, e.g. when inserting
     // with FORMAT JSONEachRow a raw JSON key-value expression is valid and expected.
     //
@@ -66,4 +70,28 @@ impl Dialect for ClickHouseDialect {
     fn supports_dictionary_syntax(&self) -> bool {
         true
     }
+
+    /// See <https://clickhouse.com/docs/en/sql-reference/functions#higher-order-functions---operator-and-lambdaparams-expr-function>
+    fn supports_lambda_functions(&self) -> bool {
+        true
+    }
+
+    fn supports_from_first_select(&self) -> bool {
+        true
+    }
+
+    /// See <https://clickhouse.com/docs/en/sql-reference/statements/select/order-by>
+    fn supports_order_by_all(&self) -> bool {
+        true
+    }
+
+    // See <https://clickhouse.com/docs/en/sql-reference/aggregate-functions/grouping_function#grouping-sets>
+    fn supports_group_by_expr(&self) -> bool {
+        true
+    }
+
+    /// See <https://clickhouse.com/docs/en/sql-reference/statements/select/group-by#rollup-modifier>
+    fn supports_group_by_with_modifier(&self) -> bool {
+        true
+    }
 }

src/dialect/duckdb.rs

@@ -65,6 +65,11 @@ impl Dialect for DuckDbDialect {
         true
     }
 
+    /// See <https://duckdb.org/docs/sql/functions/lambda.html>
+    fn supports_lambda_functions(&self) -> bool {
+        true
+    }
+
     // DuckDB is compatible with PostgreSQL syntax for this statement,
     // although not all features may be implemented.
     fn supports_explain_with_utility_options(&self) -> bool {
@@ -75,4 +80,18 @@ impl Dialect for DuckDbDialect {
     fn supports_load_extension(&self) -> bool {
         true
     }
+
+    // See DuckDB <https://duckdb.org/docs/sql/data_types/array.html#defining-an-array-field>
+    fn supports_array_typedef_with_brackets(&self) -> bool {
+        true
+    }
+
+    fn supports_from_first_select(&self) -> bool {
+        true
+    }
+
+    /// See DuckDB <https://duckdb.org/docs/sql/query_syntax/orderby.html#order-by-all-examples>
+    fn supports_order_by_all(&self) -> bool {
+        true
+    }
 }

src/dialect/generic.rs

@@ -48,6 +48,14 @@ impl Dialect for GenericDialect {
         true
     }
 
+    fn supports_group_by_with_modifier(&self) -> bool {
+        true
+    }
+
+    fn supports_left_associative_joins_without_parens(&self) -> bool {
+        true
+    }
+
     fn supports_connect_by(&self) -> bool {
         true
     }
@@ -104,6 +112,14 @@ impl Dialect for GenericDialect {
         true
     }
 
+    fn supports_from_first_select(&self) -> bool {
+        true
+    }
+
+    fn supports_projection_trailing_commas(&self) -> bool {
+        true
+    }
+
     fn supports_asc_desc_in_column_definition(&self) -> bool {
         true
     }
@@ -139,4 +155,28 @@ impl Dialect for GenericDialect {
     fn supports_user_host_grantee(&self) -> bool {
         true
     }
+
+    fn supports_string_escape_constant(&self) -> bool {
+        true
+    }
+
+    fn supports_array_typedef_with_brackets(&self) -> bool {
+        true
+    }
+
+    fn supports_match_against(&self) -> bool {
+        true
+    }
+
+    fn supports_set_names(&self) -> bool {
+        true
+    }
+
+    fn supports_comma_separated_set_assignments(&self) -> bool {
+        true
+    }
+
+    fn supports_filter_during_aggregation(&self) -> bool {
+        true
+    }
 }

src/dialect/hive.rs

@@ -52,18 +52,23 @@ impl Dialect for HiveDialect {
         true
     }
 
-    /// See Hive <https://cwiki.apache.org/confluence/pages/viewpage.action?pageId=27362061#Tutorial-BuiltInOperators>
+    /// See <https://cwiki.apache.org/confluence/pages/viewpage.action?pageId=27362061#Tutorial-BuiltInOperators>
     fn supports_bang_not_operator(&self) -> bool {
         true
     }
 
-    /// See Hive <https://cwiki.apache.org/confluence/pages/viewpage.action?pageId=27362036#LanguageManualDML-Loadingfilesintotables>
+    /// See <https://cwiki.apache.org/confluence/pages/viewpage.action?pageId=27362036#LanguageManualDML-Loadingfilesintotables>
     fn supports_load_data(&self) -> bool {
         true
     }
 
-    /// See Hive <https://cwiki.apache.org/confluence/display/hive/languagemanual+sampling>
+    /// See <https://cwiki.apache.org/confluence/display/hive/languagemanual+sampling>
     fn supports_table_sample_before_alias(&self) -> bool {
         true
     }
+
+    /// See <https://cwiki.apache.org/confluence/pages/viewpage.action?pageId=30151323#EnhancedAggregation,Cube,GroupingandRollup-CubesandRollupsr>
+    fn supports_group_by_with_modifier(&self) -> bool {
+        true
+    }
 }

src/dialect/mod.rs

@@ -49,7 +49,7 @@ pub use self::postgresql::PostgreSqlDialect;
 pub use self::redshift::RedshiftSqlDialect;
 pub use self::snowflake::SnowflakeDialect;
 pub use self::sqlite::SQLiteDialect;
-use crate::ast::{ColumnOption, Expr, Statement};
+use crate::ast::{ColumnOption, Expr, GranteesType, Statement};
 pub use crate::keywords;
 use crate::keywords::Keyword;
 use crate::parser::{Parser, ParserError};
@@ -201,6 +201,33 @@ pub trait Dialect: Debug + Any {
         false
     }
 
+    /// Determine whether the dialect strips the backslash when escaping LIKE wildcards (%, _).
+    ///
+    /// [MySQL] has a special case when escaping single quoted strings which leaves these unescaped
+    /// so they can be used in LIKE patterns without double-escaping (as is necessary in other
+    /// escaping dialects, such as [Snowflake]). Generally, special characters have escaping rules
+    /// causing them to be replaced with a different byte sequences (e.g. `'\0'` becoming the zero
+    /// byte), and the default if an escaped character does not have a specific escaping rule is to
+    /// strip the backslash (e.g. there is no rule for `h`, so `'\h' = 'h'`). MySQL's special case
+    /// for ignoring LIKE wildcard escapes is to *not* strip the backslash, so that `'\%' = '\\%'`.
+    /// This applies to all string literals though, not just those used in LIKE patterns.
+    ///
+    /// ```text
+    /// mysql> select '\_', hex('\\'), hex('_'), hex('\_');
+    /// +----+-----------+----------+-----------+
+    /// | \_ | hex('\\') | hex('_') | hex('\_') |
+    /// +----+-----------+----------+-----------+
+    /// | \_ | 5C        | 5F       | 5C5F      |
+    /// +----+-----------+----------+-----------+
+    /// 1 row in set (0.00 sec)
+    /// ```
+    ///
+    /// [MySQL]: https://dev.mysql.com/doc/refman/8.4/en/string-literals.html
+    /// [Snowflake]: https://docs.snowflake.com/en/sql-reference/functions/like#usage-notes
+    fn ignores_wildcard_escapes(&self) -> bool {
+        false
+    }
+
     /// Determine if the dialect supports string literals with `U&` prefix.
     /// This is used to specify Unicode code points in string literals.
     /// For example, in PostgreSQL, the following is a valid string literal:
@@ -245,11 +272,55 @@ pub trait Dialect: Debug + Any {
         false
     }
 
+    /// Returns true if the dialects supports `GROUP BY` modifiers prefixed by a `WITH` keyword.
+    /// Example: `GROUP BY value WITH ROLLUP`.
+    fn supports_group_by_with_modifier(&self) -> bool {
+        false
+    }
+
+    /// Indicates whether the dialect supports left-associative join parsing
+    /// by default when parentheses are omitted in nested joins.
+    ///
+    /// Most dialects (like MySQL or Postgres) assume **left-associative** precedence,
+    /// so a query like:
+    ///
+    /// ```sql
+    /// SELECT * FROM t1 NATURAL JOIN t5 INNER JOIN t0 ON ...
+    /// ```
+    /// is interpreted as:
+    /// ```sql
+    /// ((t1 NATURAL JOIN t5) INNER JOIN t0 ON ...)
+    /// ```
+    /// and internally represented as a **flat list** of joins.
+    ///
+    /// In contrast, some dialects (e.g. **Snowflake**) assume **right-associative**
+    /// precedence and interpret the same query as:
+    /// ```sql
+    /// (t1 NATURAL JOIN (t5 INNER JOIN t0 ON ...))
+    /// ```
+    /// which results in a **nested join** structure in the AST.
+    ///
+    /// If this method returns `false`, the parser must build nested join trees
+    /// even in the absence of parentheses to reflect the correct associativity
+    fn supports_left_associative_joins_without_parens(&self) -> bool {
+        true
+    }
+
+    /// Returns true if the dialect supports the `(+)` syntax for OUTER JOIN.
+    fn supports_outer_join_operator(&self) -> bool {
+        false
+    }
+
     /// Returns true if the dialect supports CONNECT BY.
     fn supports_connect_by(&self) -> bool {
         false
     }
 
+    /// Returns true if the dialect supports `EXECUTE IMMEDIATE` statements.
+    fn supports_execute_immediate(&self) -> bool {
+        false
+    }
+
     /// Returns true if the dialect supports the MATCH_RECOGNIZE operation.
     fn supports_match_recognize(&self) -> bool {
         false
@@ -304,6 +375,11 @@ pub trait Dialect: Debug + Any {
         false
     }
 
+    /// Returns true if the dialect supports numbers containing underscores, e.g. `10_000_000`
+    fn supports_numeric_literal_underscores(&self) -> bool {
+        false
+    }
+
     /// Returns true if the dialects supports specifying null treatment
     /// as part of a window function's parameter list as opposed
     /// to after the parameter list.
@@ -341,15 +417,6 @@ pub trait Dialect: Debug + Any {
         false
     }
 
-    /// Returns true if the dialect supports method calls, for example:
-    ///
-    /// ```sql
-    /// SELECT (SELECT ',' + name FROM sys.objects  FOR XML PATH(''), TYPE).value('.','NVARCHAR(MAX)')
-    /// ```
-    fn supports_methods(&self) -> bool {
-        false
-    }
-
     /// Returns true if the dialect supports multiple variable assignment
     /// using parentheses in a `SET` variable declaration.
     ///
@@ -360,6 +427,16 @@ pub trait Dialect: Debug + Any {
         false
     }
 
+    /// Returns true if the dialect supports multiple `SET` statements
+    /// in a single statement.
+    ///
+    /// ```sql
+    /// SET variable = expression [, variable = expression];
+    /// ```
+    fn supports_comma_separated_set_assignments(&self) -> bool {
+        false
+    }
+
     /// Returns true if the dialect supports an `EXCEPT` clause following a
     /// wildcard in a select list.
     ///
@@ -405,11 +482,18 @@ pub trait Dialect: Debug + Any {
     }
 
     /// Returns true if the dialect supports trailing commas in the `FROM` clause of a `SELECT` statement.
-    /// /// Example: `SELECT 1 FROM T, U, LIMIT 1`
+    /// Example: `SELECT 1 FROM T, U, LIMIT 1`
     fn supports_from_trailing_commas(&self) -> bool {
         false
     }
 
+    /// Returns true if the dialect supports trailing commas in the
+    /// column definitions list of a `CREATE` statement.
+    /// Example: `CREATE TABLE T (x INT, y TEXT,)`
+    fn supports_column_definition_trailing_commas(&self) -> bool {
+        false
+    }
+
     /// Returns true if the dialect supports double dot notation for object names
     ///
     /// Example
@@ -440,11 +524,52 @@ pub trait Dialect: Debug + Any {
         false
     }
 
+    /// Return true if the dialect supports wildcard expansion on
+    /// arbitrary expressions in projections.
+    ///
+    /// Example:
+    /// ```sql
+    /// SELECT STRUCT<STRING>('foo').* FROM T
+    /// ```
+    fn supports_select_expr_star(&self) -> bool {
+        false
+    }
+
+    /// Return true if the dialect supports "FROM-first" selects.
+    ///
+    /// Example:
+    /// ```sql
+    /// FROM table
+    /// SELECT *
+    /// ```
+    fn supports_from_first_select(&self) -> bool {
+        false
+    }
+
+    /// Return true if the dialect supports pipe operator.
+    ///
+    /// Example:
+    /// ```sql
+    /// SELECT *
+    /// FROM table
+    /// |> limit 1
+    /// ```
+    ///
+    /// See <https://cloud.google.com/bigquery/docs/pipe-syntax-guide#basic_syntax>
+    fn supports_pipe_operator(&self) -> bool {
+        false
+    }
+
     /// Does the dialect support MySQL-style `'user'@'host'` grantee syntax?
     fn supports_user_host_grantee(&self) -> bool {
         false
     }
 
+    /// Does the dialect support the `MATCH() AGAINST()` syntax?
+    fn supports_match_against(&self) -> bool {
+        false
+    }
+
     /// Dialect-specific infix parser override
     ///
     /// This method is called to parse the next infix expression.
@@ -490,7 +615,7 @@ pub trait Dialect: Debug + Any {
         }
 
         let token = parser.peek_token();
-        debug!("get_next_precedence_full() {:?}", token);
+        debug!("get_next_precedence_full() {token:?}");
         match token.token {
             Token::Word(w) if w.keyword == Keyword::OR => Ok(p!(Or)),
             Token::Word(w) if w.keyword == Keyword::AND => Ok(p!(And)),
@@ -522,7 +647,9 @@ pub trait Dialect: Debug + Any {
                 Token::Word(w) if w.keyword == Keyword::ILIKE => Ok(p!(Like)),
                 Token::Word(w) if w.keyword == Keyword::RLIKE => Ok(p!(Like)),
                 Token::Word(w) if w.keyword == Keyword::REGEXP => Ok(p!(Like)),
+                Token::Word(w) if w.keyword == Keyword::MATCH => Ok(p!(Like)),
                 Token::Word(w) if w.keyword == Keyword::SIMILAR => Ok(p!(Like)),
+                Token::Word(w) if w.keyword == Keyword::MEMBER => Ok(p!(Like)),
                 _ => Ok(self.prec_unknown()),
             },
             Token::Word(w) if w.keyword == Keyword::IS => Ok(p!(Is)),
@@ -533,10 +660,14 @@ pub trait Dialect: Debug + Any {
             Token::Word(w) if w.keyword == Keyword::ILIKE => Ok(p!(Like)),
             Token::Word(w) if w.keyword == Keyword::RLIKE => Ok(p!(Like)),
             Token::Word(w) if w.keyword == Keyword::REGEXP => Ok(p!(Like)),
+            Token::Word(w) if w.keyword == Keyword::MATCH => Ok(p!(Like)),
             Token::Word(w) if w.keyword == Keyword::SIMILAR => Ok(p!(Like)),
+            Token::Word(w) if w.keyword == Keyword::MEMBER => Ok(p!(Like)),
             Token::Word(w) if w.keyword == Keyword::OPERATOR => Ok(p!(Between)),
             Token::Word(w) if w.keyword == Keyword::DIV => Ok(p!(MulDivModOp)),
-            Token::Eq
+            Token::Period => Ok(p!(Period)),
+            Token::Assignment
+            | Token::Eq
             | Token::Lt
             | Token::LtEq
             | Token::Neq
@@ -552,18 +683,34 @@ pub trait Dialect: Debug + Any {
             | Token::ExclamationMarkDoubleTilde
             | Token::ExclamationMarkDoubleTildeAsterisk
             | Token::Spaceship => Ok(p!(Eq)),
-            Token::Pipe => Ok(p!(Pipe)),
+            Token::Pipe
+            | Token::QuestionMarkDash
+            | Token::DoubleSharp
+            | Token::Overlap
+            | Token::AmpersandLeftAngleBracket
+            | Token::AmpersandRightAngleBracket
+            | Token::QuestionMarkDashVerticalBar
+            | Token::AmpersandLeftAngleBracketVerticalBar
+            | Token::VerticalBarAmpersandRightAngleBracket
+            | Token::TwoWayArrow
+            | Token::LeftAngleBracketCaret
+            | Token::RightAngleBracketCaret
+            | Token::QuestionMarkSharp
+            | Token::QuestionMarkDoubleVerticalBar
+            | Token::QuestionPipe
+            | Token::TildeEqual
+            | Token::AtSign
+            | Token::ShiftLeftVerticalBar
+            | Token::VerticalBarShiftRight => Ok(p!(Pipe)),
             Token::Caret | Token::Sharp | Token::ShiftRight | Token::ShiftLeft => Ok(p!(Caret)),
             Token::Ampersand => Ok(p!(Ampersand)),
             Token::Plus | Token::Minus => Ok(p!(PlusMinus)),
             Token::Mul | Token::Div | Token::DuckIntDiv | Token::Mod | Token::StringConcat => {
                 Ok(p!(MulDivModOp))
             }
-            Token::DoubleColon
-            | Token::ExclamationMark
-            | Token::LBracket
-            | Token::Overlap
-            | Token::CaretAt => Ok(p!(DoubleColon)),
+            Token::DoubleColon | Token::ExclamationMark | Token::LBracket | Token::CaretAt => {
+                Ok(p!(DoubleColon))
+            }
             Token::Arrow
             | Token::LongArrow
             | Token::HashArrow
@@ -575,7 +722,6 @@ pub trait Dialect: Debug + Any {
             | Token::AtAt
             | Token::Question
             | Token::QuestionAnd
-            | Token::QuestionPipe
             | Token::CustomBinaryOperator(_) => Ok(p!(PgOther)),
             _ => Ok(self.prec_unknown()),
         }
@@ -609,6 +755,7 @@ pub trait Dialect: Debug + Any {
     /// Uses (APPROXIMATELY) <https://www.postgresql.org/docs/7.0/operators.htm#AEN2026> as a reference
     fn prec_value(&self, prec: Precedence) -> u8 {
         match prec {
+            Precedence::Period => 100,
             Precedence::DoubleColon => 50,
             Precedence::AtTz => 41,
             Precedence::MulDivModOp => 40,
@@ -781,12 +928,23 @@ pub trait Dialect: Debug + Any {
         keywords::RESERVED_FOR_IDENTIFIER.contains(&kw)
     }
 
-    // Returns reserved keywords when looking to parse a [TableFactor].
+    /// Returns reserved keywords when looking to parse a `TableFactor`.
     /// See [Self::supports_from_trailing_commas]
     fn get_reserved_keywords_for_table_factor(&self) -> &[Keyword] {
         keywords::RESERVED_FOR_TABLE_FACTOR
     }
 
+    /// Returns reserved keywords that may prefix a select item expression
+    /// e.g. `SELECT CONNECT_BY_ROOT name FROM Tbl2` (Snowflake)
+    fn get_reserved_keywords_for_select_item_operator(&self) -> &[Keyword] {
+        &[]
+    }
+
+    /// Returns grantee types that should be treated as identifiers
+    fn get_reserved_grantees_types(&self) -> &[GranteesType] {
+        &[]
+    }
+
     /// Returns true if this dialect supports the `TABLESAMPLE` option
     /// before the table alias option. For example:
     ///
@@ -821,11 +979,17 @@ pub trait Dialect: Debug + Any {
         false
     }
 
+    /// Returns true if the specified keyword should be parsed as a column identifier.
+    /// See [keywords::RESERVED_FOR_COLUMN_ALIAS]
+    fn is_column_alias(&self, kw: &Keyword, _parser: &mut Parser) -> bool {
+        !keywords::RESERVED_FOR_COLUMN_ALIAS.contains(kw)
+    }
+
     /// Returns true if the specified keyword should be parsed as a select item alias.
     /// When explicit is true, the keyword is preceded by an `AS` word. Parser is provided
     /// to enable looking ahead if needed.
-    fn is_select_item_alias(&self, explicit: bool, kw: &Keyword, _parser: &mut Parser) -> bool {
-        explicit || !keywords::RESERVED_FOR_COLUMN_ALIAS.contains(kw)
+    fn is_select_item_alias(&self, explicit: bool, kw: &Keyword, parser: &mut Parser) -> bool {
+        explicit || self.is_column_alias(kw, parser)
     }
 
     /// Returns true if the specified keyword should be parsed as a table factor alias.
@@ -840,6 +1004,78 @@ pub trait Dialect: Debug + Any {
     fn supports_timestamp_versioning(&self) -> bool {
         false
     }
+
+    /// Returns true if this dialect supports the E'...' syntax for string literals
+    ///
+    /// Postgres: <https://www.postgresql.org/docs/current/sql-syntax-lexical.html#SQL-SYNTAX-STRINGS-ESCAPE>
+    fn supports_string_escape_constant(&self) -> bool {
+        false
+    }
+
+    /// Returns true if the dialect supports the table hints in the `FROM` clause.
+    fn supports_table_hints(&self) -> bool {
+        false
+    }
+
+    /// Returns true if this dialect requires a whitespace character after `--` to start a single line comment.
+    ///
+    /// MySQL: <https://dev.mysql.com/doc/refman/8.4/en/ansi-diff-comments.html>
+    /// e.g. UPDATE account SET balance=balance--1
+    //       WHERE account_id=5752             ^^^ will be interpreted as two minus signs instead of a comment
+    fn requires_single_line_comment_whitespace(&self) -> bool {
+        false
+    }
+
+    /// Returns true if the dialect supports array type definition with brackets with
+    /// an optional size. For example:
+    /// ```CREATE TABLE my_table (arr1 INT[], arr2 INT[3])```
+    /// ```SELECT x::INT[]```
+    fn supports_array_typedef_with_brackets(&self) -> bool {
+        false
+    }
+    /// Returns true if the dialect supports geometric types.
+    ///
+    /// Postgres: <https://www.postgresql.org/docs/9.5/functions-geometry.html>
+    /// e.g. @@ circle '((0,0),10)'
+    fn supports_geometric_types(&self) -> bool {
+        false
+    }
+
+    /// Returns true if the dialect supports `ORDER BY ALL`.
+    /// `ALL` which means all columns of the SELECT clause.
+    ///
+    /// For example: ```SELECT * FROM addresses ORDER BY ALL;```.
+    fn supports_order_by_all(&self) -> bool {
+        false
+    }
+
+    /// Returns true if the dialect supports `SET NAMES <charset_name> [COLLATE <collation_name>]`.
+    ///
+    /// - [MySQL](https://dev.mysql.com/doc/refman/8.4/en/set-names.html)
+    /// - [PostgreSQL](https://www.postgresql.org/docs/17/sql-set.html)
+    ///
+    /// Note: Postgres doesn't support the `COLLATE` clause, but we permissively parse it anyway.
+    fn supports_set_names(&self) -> bool {
+        false
+    }
+
+    fn supports_space_separated_column_options(&self) -> bool {
+        false
+    }
+
+    /// Returns true if the dialect supports the `USING` clause in an `ALTER COLUMN` statement.
+    /// Example:
+    ///  ```sql
+    ///  ALTER TABLE tbl ALTER COLUMN col SET DATA TYPE <type> USING <exp>`
+    /// ```
+    fn supports_alter_column_type_using(&self) -> bool {
+        false
+    }
+
+    /// Returns true if the dialect supports `ALTER TABLE tbl DROP COLUMN c1, ..., cn`
+    fn supports_comma_separated_drop_column_list(&self) -> bool {
+        false
+    }
 }
 
 /// This represents the operators for which precedence must be defined
@@ -847,6 +1083,7 @@ pub trait Dialect: Debug + Any {
 /// higher number -> higher precedence
 #[derive(Debug, Clone, Copy)]
 pub enum Precedence {
+    Period,
     DoubleColon,
     AtTz,
     MulDivModOp,

src/dialect/mssql.rs

@@ -15,7 +15,19 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use crate::ast::helpers::attached_token::AttachedToken;
+use crate::ast::{
+    BeginEndStatements, ConditionalStatementBlock, ConditionalStatements, GranteesType,
+    IfStatement, Statement, TriggerObject,
+};
 use crate::dialect::Dialect;
+use crate::keywords::{self, Keyword};
+use crate::parser::{Parser, ParserError};
+use crate::tokenizer::Token;
+#[cfg(not(feature = "std"))]
+use alloc::{vec, vec::Vec};
+
+const RESERVED_FOR_COLUMN_ALIAS: &[Keyword] = &[Keyword::IF, Keyword::ELSE];
 
 /// A [`Dialect`] for [Microsoft SQL Server](https://www.microsoft.com/en-us/sql-server/)
 #[derive(Debug)]
@@ -40,12 +52,20 @@ impl Dialect for MsSqlDialect {
             || ch == '_'
     }
 
+    fn identifier_quote_style(&self, _identifier: &str) -> Option<char> {
+        Some('[')
+    }
+
     /// SQL Server has `CONVERT(type, value)` instead of `CONVERT(value, type)`
     /// <https://learn.microsoft.com/en-us/sql/t-sql/functions/cast-and-convert-transact-sql?view=sql-server-ver16>
     fn convert_type_before_value(&self) -> bool {
         true
     }
 
+    fn supports_outer_join_operator(&self) -> bool {
+        true
+    }
+
     fn supports_connect_by(&self) -> bool {
         true
     }
@@ -63,10 +83,6 @@ impl Dialect for MsSqlDialect {
         false
     }
 
-    fn supports_methods(&self) -> bool {
-        true
-    }
-
     fn supports_named_fn_args_with_colon_operator(&self) -> bool {
         true
     }
@@ -82,6 +98,7 @@ impl Dialect for MsSqlDialect {
     fn supports_start_transaction_modifier(&self) -> bool {
         true
     }
+
     fn supports_end_transaction_modifier(&self) -> bool {
         true
     }
@@ -95,4 +112,187 @@ impl Dialect for MsSqlDialect {
     fn supports_timestamp_versioning(&self) -> bool {
         true
     }
+
+    /// See <https://learn.microsoft.com/en-us/sql/t-sql/language-elements/slash-star-comment-transact-sql?view=sql-server-ver16>
+    fn supports_nested_comments(&self) -> bool {
+        true
+    }
+
+    /// See <https://learn.microsoft.com/en-us/sql/t-sql/queries/from-transact-sql>
+    fn supports_object_name_double_dot_notation(&self) -> bool {
+        true
+    }
+
+    /// See <https://learn.microsoft.com/en-us/sql/relational-databases/security/authentication-access/server-level-roles>
+    fn get_reserved_grantees_types(&self) -> &[GranteesType] {
+        &[GranteesType::Public]
+    }
+
+    fn is_column_alias(&self, kw: &Keyword, _parser: &mut Parser) -> bool {
+        !keywords::RESERVED_FOR_COLUMN_ALIAS.contains(kw) && !RESERVED_FOR_COLUMN_ALIAS.contains(kw)
+    }
+
+    fn parse_statement(&self, parser: &mut Parser) -> Option<Result<Statement, ParserError>> {
+        if parser.peek_keyword(Keyword::IF) {
+            Some(self.parse_if_stmt(parser))
+        } else if parser.parse_keywords(&[Keyword::CREATE, Keyword::TRIGGER]) {
+            Some(self.parse_create_trigger(parser, false))
+        } else if parser.parse_keywords(&[
+            Keyword::CREATE,
+            Keyword::OR,
+            Keyword::ALTER,
+            Keyword::TRIGGER,
+        ]) {
+            Some(self.parse_create_trigger(parser, true))
+        } else {
+            None
+        }
+    }
+}
+
+impl MsSqlDialect {
+    /// ```sql
+    /// IF boolean_expression
+    ///     { sql_statement | statement_block }
+    /// [ ELSE
+    ///     { sql_statement | statement_block } ]
+    /// ```
+    fn parse_if_stmt(&self, parser: &mut Parser) -> Result<Statement, ParserError> {
+        let if_token = parser.expect_keyword(Keyword::IF)?;
+
+        let condition = parser.parse_expr()?;
+
+        let if_block = if parser.peek_keyword(Keyword::BEGIN) {
+            let begin_token = parser.expect_keyword(Keyword::BEGIN)?;
+            let statements = self.parse_statement_list(parser, Some(Keyword::END))?;
+            let end_token = parser.expect_keyword(Keyword::END)?;
+            ConditionalStatementBlock {
+                start_token: AttachedToken(if_token),
+                condition: Some(condition),
+                then_token: None,
+                conditional_statements: ConditionalStatements::BeginEnd(BeginEndStatements {
+                    begin_token: AttachedToken(begin_token),
+                    statements,
+                    end_token: AttachedToken(end_token),
+                }),
+            }
+        } else {
+            let stmt = parser.parse_statement()?;
+            ConditionalStatementBlock {
+                start_token: AttachedToken(if_token),
+                condition: Some(condition),
+                then_token: None,
+                conditional_statements: ConditionalStatements::Sequence {
+                    statements: vec![stmt],
+                },
+            }
+        };
+
+        let mut prior_statement_ended_with_semi_colon = false;
+        while let Token::SemiColon = parser.peek_token_ref().token {
+            parser.advance_token();
+            prior_statement_ended_with_semi_colon = true;
+        }
+
+        let mut else_block = None;
+        if parser.peek_keyword(Keyword::ELSE) {
+            let else_token = parser.expect_keyword(Keyword::ELSE)?;
+            if parser.peek_keyword(Keyword::BEGIN) {
+                let begin_token = parser.expect_keyword(Keyword::BEGIN)?;
+                let statements = self.parse_statement_list(parser, Some(Keyword::END))?;
+                let end_token = parser.expect_keyword(Keyword::END)?;
+                else_block = Some(ConditionalStatementBlock {
+                    start_token: AttachedToken(else_token),
+                    condition: None,
+                    then_token: None,
+                    conditional_statements: ConditionalStatements::BeginEnd(BeginEndStatements {
+                        begin_token: AttachedToken(begin_token),
+                        statements,
+                        end_token: AttachedToken(end_token),
+                    }),
+                });
+            } else {
+                let stmt = parser.parse_statement()?;
+                else_block = Some(ConditionalStatementBlock {
+                    start_token: AttachedToken(else_token),
+                    condition: None,
+                    then_token: None,
+                    conditional_statements: ConditionalStatements::Sequence {
+                        statements: vec![stmt],
+                    },
+                });
+            }
+        } else if prior_statement_ended_with_semi_colon {
+            parser.prev_token();
+        }
+
+        Ok(Statement::If(IfStatement {
+            if_block,
+            else_block,
+            elseif_blocks: Vec::new(),
+            end_token: None,
+        }))
+    }
+
+    /// Parse `CREATE TRIGGER` for [MsSql]
+    ///
+    /// [MsSql]: https://learn.microsoft.com/en-us/sql/t-sql/statements/create-trigger-transact-sql
+    fn parse_create_trigger(
+        &self,
+        parser: &mut Parser,
+        or_alter: bool,
+    ) -> Result<Statement, ParserError> {
+        let name = parser.parse_object_name(false)?;
+        parser.expect_keyword_is(Keyword::ON)?;
+        let table_name = parser.parse_object_name(false)?;
+        let period = parser.parse_trigger_period()?;
+        let events = parser.parse_comma_separated(Parser::parse_trigger_event)?;
+
+        parser.expect_keyword_is(Keyword::AS)?;
+        let statements = Some(parser.parse_conditional_statements(&[Keyword::END])?);
+
+        Ok(Statement::CreateTrigger {
+            or_alter,
+            or_replace: false,
+            is_constraint: false,
+            name,
+            period,
+            events,
+            table_name,
+            referenced_table_name: None,
+            referencing: Vec::new(),
+            trigger_object: TriggerObject::Statement,
+            include_each: false,
+            condition: None,
+            exec_body: None,
+            statements,
+            characteristics: None,
+        })
+    }
+
+    /// Parse a sequence of statements, optionally separated by semicolon.
+    ///
+    /// Stops parsing when reaching EOF or the given keyword.
+    fn parse_statement_list(
+        &self,
+        parser: &mut Parser,
+        terminal_keyword: Option<Keyword>,
+    ) -> Result<Vec<Statement>, ParserError> {
+        let mut stmts = Vec::new();
+        loop {
+            if let Token::EOF = parser.peek_token_ref().token {
+                break;
+            }
+            if let Some(term) = terminal_keyword {
+                if parser.peek_keyword(term) {
+                    break;
+                }
+            }
+            stmts.push(parser.parse_statement()?);
+            while let Token::SemiColon = parser.peek_token_ref().token {
+                parser.advance_token();
+            }
+        }
+        Ok(stmts)
+    }
 }

src/dialect/mysql.rs

@@ -25,6 +25,15 @@ use crate::{
     parser::{Parser, ParserError},
 };
 
+use super::keywords;
+
+const RESERVED_FOR_TABLE_ALIAS_MYSQL: &[Keyword] = &[
+    Keyword::USE,
+    Keyword::IGNORE,
+    Keyword::FORCE,
+    Keyword::STRAIGHT_JOIN,
+];
+
 /// A [`Dialect`] for [MySQL](https://www.mysql.com/)
 #[derive(Debug)]
 pub struct MySqlDialect {}
@@ -58,6 +67,10 @@ impl Dialect for MySqlDialect {
         true
     }
 
+    fn ignores_wildcard_escapes(&self) -> bool {
+        true
+    }
+
     fn supports_numeric_prefix(&self) -> bool {
         true
     }
@@ -111,6 +124,32 @@ impl Dialect for MySqlDialect {
     fn supports_user_host_grantee(&self) -> bool {
         true
     }
+
+    fn is_table_factor_alias(&self, explicit: bool, kw: &Keyword, _parser: &mut Parser) -> bool {
+        explicit
+            || (!keywords::RESERVED_FOR_TABLE_ALIAS.contains(kw)
+                && !RESERVED_FOR_TABLE_ALIAS_MYSQL.contains(kw))
+    }
+
+    fn supports_table_hints(&self) -> bool {
+        true
+    }
+
+    fn requires_single_line_comment_whitespace(&self) -> bool {
+        true
+    }
+
+    fn supports_match_against(&self) -> bool {
+        true
+    }
+
+    fn supports_set_names(&self) -> bool {
+        true
+    }
+
+    fn supports_comma_separated_set_assignments(&self) -> bool {
+        true
+    }
 }
 
 /// `LOCK TABLES`

src/dialect/postgresql.rs

@@ -28,7 +28,6 @@
 // limitations under the License.
 use log::debug;
 
-use crate::ast::{ObjectName, Statement, UserDefinedTypeRepresentation};
 use crate::dialect::{Dialect, Precedence};
 use crate::keywords::Keyword;
 use crate::parser::{Parser, ParserError};
@@ -38,6 +37,7 @@ use crate::tokenizer::Token;
 #[derive(Debug)]
 pub struct PostgreSqlDialect {}
 
+const PERIOD_PREC: u8 = 200;
 const DOUBLE_COLON_PREC: u8 = 140;
 const BRACKET_PREC: u8 = 130;
 const COLLATE_PREC: u8 = 120;
@@ -104,7 +104,7 @@ impl Dialect for PostgreSqlDialect {
 
     fn get_next_precedence(&self, parser: &Parser) -> Option<Result<u8, ParserError>> {
         let token = parser.peek_token();
-        debug!("get_next_precedence() {:?}", token);
+        debug!("get_next_precedence() {token:?}");
 
         // we only return some custom value here when the behaviour (not merely the numeric value) differs
         // from the default implementation
@@ -135,15 +135,6 @@ impl Dialect for PostgreSqlDialect {
         }
     }
 
-    fn parse_statement(&self, parser: &mut Parser) -> Option<Result<Statement, ParserError>> {
-        if parser.parse_keyword(Keyword::CREATE) {
-            parser.prev_token(); // unconsume the CREATE in case we don't end up parsing anything
-            parse_create(parser)
-        } else {
-            None
-        }
-    }
-
     fn supports_filter_during_aggregation(&self) -> bool {
         true
     }
@@ -154,6 +145,7 @@ impl Dialect for PostgreSqlDialect {
 
     fn prec_value(&self, prec: Precedence) -> u8 {
         match prec {
+            Precedence::Period => PERIOD_PREC,
             Precedence::DoubleColon => DOUBLE_COLON_PREC,
             Precedence::AtTz => AT_TZ_PREC,
             Precedence::MulDivModOp => MUL_DIV_MOD_OP_PREC,
@@ -245,38 +237,29 @@ impl Dialect for PostgreSqlDialect {
     fn supports_nested_comments(&self) -> bool {
         true
     }
-}
 
-pub fn parse_create(parser: &mut Parser) -> Option<Result<Statement, ParserError>> {
-    let name = parser.maybe_parse(|parser| -> Result<ObjectName, ParserError> {
-        parser.expect_keyword_is(Keyword::CREATE)?;
-        parser.expect_keyword_is(Keyword::TYPE)?;
-        let name = parser.parse_object_name(false)?;
-        parser.expect_keyword_is(Keyword::AS)?;
-        parser.expect_keyword_is(Keyword::ENUM)?;
-        Ok(name)
-    });
-
-    match name {
-        Ok(name) => name.map(|name| parse_create_type_as_enum(parser, name)),
-        Err(e) => Some(Err(e)),
-    }
-}
-
-// https://www.postgresql.org/docs/current/sql-createtype.html
-pub fn parse_create_type_as_enum(
-    parser: &mut Parser,
-    name: ObjectName,
-) -> Result<Statement, ParserError> {
-    if !parser.consume_token(&Token::LParen) {
-        return parser.expected("'(' after CREATE TYPE AS ENUM", parser.peek_token());
+    fn supports_string_escape_constant(&self) -> bool {
+        true
     }
 
-    let labels = parser.parse_comma_separated0(|p| p.parse_identifier(), Token::RParen)?;
-    parser.expect_token(&Token::RParen)?;
+    fn supports_numeric_literal_underscores(&self) -> bool {
+        true
+    }
 
-    Ok(Statement::CreateType {
-        name,
-        representation: UserDefinedTypeRepresentation::Enum { labels },
-    })
+    /// See: <https://www.postgresql.org/docs/current/arrays.html#ARRAYS-DECLARATION>
+    fn supports_array_typedef_with_brackets(&self) -> bool {
+        true
+    }
+
+    fn supports_geometric_types(&self) -> bool {
+        true
+    }
+
+    fn supports_set_names(&self) -> bool {
+        true
+    }
+
+    fn supports_alter_column_type_using(&self) -> bool {
+        true
+    }
 }

src/dialect/redshift.rs

@@ -80,13 +80,15 @@ impl Dialect for RedshiftSqlDialect {
     }
 
     fn is_identifier_start(&self, ch: char) -> bool {
-        // Extends Postgres dialect with sharp
-        PostgreSqlDialect {}.is_identifier_start(ch) || ch == '#'
+        // Extends Postgres dialect with sharp and UTF-8 multibyte chars
+        // https://docs.aws.amazon.com/redshift/latest/dg/r_names.html
+        PostgreSqlDialect {}.is_identifier_start(ch) || ch == '#' || !ch.is_ascii()
     }
 
     fn is_identifier_part(&self, ch: char) -> bool {
-        // Extends Postgres dialect with sharp
-        PostgreSqlDialect {}.is_identifier_part(ch) || ch == '#'
+        // Extends Postgres dialect with sharp and UTF-8 multibyte chars
+        // https://docs.aws.amazon.com/redshift/latest/dg/r_names.html
+        PostgreSqlDialect {}.is_identifier_part(ch) || ch == '#' || !ch.is_ascii()
     }
 
     /// redshift has `CONVERT(type, value)` instead of `CONVERT(value, type)`
@@ -109,4 +111,24 @@ impl Dialect for RedshiftSqlDialect {
     fn supports_partiql(&self) -> bool {
         true
     }
+
+    fn supports_string_escape_constant(&self) -> bool {
+        true
+    }
+
+    fn supports_geometric_types(&self) -> bool {
+        true
+    }
+
+    fn supports_array_typedef_with_brackets(&self) -> bool {
+        true
+    }
+
+    fn allow_extract_single_quotes(&self) -> bool {
+        true
+    }
+
+    fn supports_string_literal_backslash_escape(&self) -> bool {
+        true
+    }
 }

src/dialect/snowflake.rs

@@ -17,20 +17,23 @@
 
 #[cfg(not(feature = "std"))]
 use crate::alloc::string::ToString;
+use crate::ast::helpers::key_value_options::{KeyValueOption, KeyValueOptionType, KeyValueOptions};
 use crate::ast::helpers::stmt_create_table::CreateTableBuilder;
 use crate::ast::helpers::stmt_data_loading::{
-    DataLoadingOption, DataLoadingOptionType, DataLoadingOptions, FileStagingCommand,
-    StageLoadSelectItem, StageParamsObject,
+    FileStagingCommand, StageLoadSelectItem, StageLoadSelectItemKind, StageParamsObject,
 };
 use crate::ast::{
-    ColumnOption, ColumnPolicy, ColumnPolicyProperty, Ident, IdentityParameters, IdentityProperty,
-    IdentityPropertyFormatKind, IdentityPropertyKind, IdentityPropertyOrder, ObjectName,
-    RowAccessPolicy, Statement, TagsColumnOption, WrappedCollection,
+    ColumnOption, ColumnPolicy, ColumnPolicyProperty, CopyIntoSnowflakeKind, Ident,
+    IdentityParameters, IdentityProperty, IdentityPropertyFormatKind, IdentityPropertyKind,
+    IdentityPropertyOrder, ObjectName, RowAccessPolicy, ShowObjects, SqlOption, Statement,
+    TagsColumnOption, WrappedCollection,
 };
 use crate::dialect::{Dialect, Precedence};
 use crate::keywords::Keyword;
-use crate::parser::{Parser, ParserError};
-use crate::tokenizer::Token;
+use crate::parser::{IsOptional, Parser, ParserError};
+use crate::tokenizer::{Token, Word};
+#[cfg(not(feature = "std"))]
+use alloc::boxed::Box;
 #[cfg(not(feature = "std"))]
 use alloc::string::String;
 #[cfg(not(feature = "std"))]
@@ -39,7 +42,9 @@ use alloc::vec::Vec;
 use alloc::{format, vec};
 
 use super::keywords::RESERVED_FOR_IDENTIFIER;
+use sqlparser::ast::StorageSerializationPolicy;
 
+const RESERVED_KEYWORDS_FOR_SELECT_ITEM_OPERATOR: [Keyword; 1] = [Keyword::CONNECT_BY_ROOT];
 /// A [`Dialect`] for [Snowflake](https://www.snowflake.com/)
 #[derive(Debug, Default)]
 pub struct SnowflakeDialect;
@@ -83,10 +88,20 @@ impl Dialect for SnowflakeDialect {
         true
     }
 
+    /// See <https://docs.snowflake.com/en/sql-reference/constructs/where#joins-in-the-where-clause>
+    fn supports_outer_join_operator(&self) -> bool {
+        true
+    }
+
     fn supports_connect_by(&self) -> bool {
         true
     }
 
+    /// See <https://docs.snowflake.com/en/sql-reference/sql/execute-immediate>
+    fn supports_execute_immediate(&self) -> bool {
+        true
+    }
+
     fn supports_match_recognize(&self) -> bool {
         true
     }
@@ -116,6 +131,20 @@ impl Dialect for SnowflakeDialect {
     }
 
     fn parse_statement(&self, parser: &mut Parser) -> Option<Result<Statement, ParserError>> {
+        if parser.parse_keyword(Keyword::BEGIN) {
+            return Some(parser.parse_begin_exception_end());
+        }
+
+        if parser.parse_keywords(&[Keyword::ALTER, Keyword::SESSION]) {
+            // ALTER SESSION
+            let set = match parser.parse_one_of_keywords(&[Keyword::SET, Keyword::UNSET]) {
+                Some(Keyword::SET) => true,
+                Some(Keyword::UNSET) => false,
+                _ => return Some(parser.expected("SET or UNSET", parser.peek_token())),
+            };
+            return Some(parse_alter_session(parser, set));
+        }
+
         if parser.parse_keyword(Keyword::CREATE) {
             // possibly CREATE STAGE
             //[ OR  REPLACE ]
@@ -130,16 +159,19 @@ impl Dialect for SnowflakeDialect {
             let mut temporary = false;
             let mut volatile = false;
             let mut transient = false;
+            let mut iceberg = false;
 
             match parser.parse_one_of_keywords(&[
                 Keyword::TEMP,
                 Keyword::TEMPORARY,
                 Keyword::VOLATILE,
                 Keyword::TRANSIENT,
+                Keyword::ICEBERG,
             ]) {
                 Some(Keyword::TEMP | Keyword::TEMPORARY) => temporary = true,
                 Some(Keyword::VOLATILE) => volatile = true,
                 Some(Keyword::TRANSIENT) => transient = true,
+                Some(Keyword::ICEBERG) => iceberg = true,
                 _ => {}
             }
 
@@ -148,7 +180,7 @@ impl Dialect for SnowflakeDialect {
                 return Some(parse_create_stage(or_replace, temporary, parser));
             } else if parser.parse_keyword(Keyword::TABLE) {
                 return Some(parse_create_table(
-                    or_replace, global, temporary, volatile, transient, parser,
+                    or_replace, global, temporary, volatile, transient, iceberg, parser,
                 ));
             } else {
                 // need to go back with the cursor
@@ -178,6 +210,19 @@ impl Dialect for SnowflakeDialect {
             return Some(parse_file_staging_command(kw, parser));
         }
 
+        if parser.parse_keyword(Keyword::SHOW) {
+            let terse = parser.parse_keyword(Keyword::TERSE);
+            if parser.parse_keyword(Keyword::OBJECTS) {
+                return Some(parse_show_objects(terse, parser));
+            }
+            //Give back Keyword::TERSE
+            if terse {
+                parser.prev_token();
+            }
+            //Give back Keyword::SHOW
+            parser.prev_token();
+        }
+
         None
     }
 
@@ -238,6 +283,10 @@ impl Dialect for SnowflakeDialect {
         true
     }
 
+    fn supports_left_associative_joins_without_parens(&self) -> bool {
+        false
+    }
+
     fn is_reserved_for_identifier(&self, kw: Keyword) -> bool {
         // Unreserve some keywords that Snowflake accepts as identifiers
         // See: https://docs.snowflake.com/en/sql-reference/reserved-keywords
@@ -252,9 +301,8 @@ impl Dialect for SnowflakeDialect {
         true
     }
 
-    fn is_select_item_alias(&self, explicit: bool, kw: &Keyword, parser: &mut Parser) -> bool {
-        explicit
-            || match kw {
+    fn is_column_alias(&self, kw: &Keyword, parser: &mut Parser) -> bool {
+        match kw {
             // The following keywords can be considered an alias as long as 
             // they are not followed by other tokens that may change their meaning
             // e.g. `SELECT * EXCEPT (col1) FROM tbl`
@@ -270,7 +318,7 @@ impl Dialect for SnowflakeDialect {
             }
 
             // `FETCH` can be considered an alias as long as it's not followed by `FIRST`` or `NEXT`
-            // which would give it a different meanins, for example: `SELECT 1 FETCH FIRST 10 ROWS` - not an alias
+            // which would give it a different meanings, for example: `SELECT 1 FETCH FIRST 10 ROWS` - not an alias
             Keyword::FETCH
                 if parser.peek_keyword(Keyword::FIRST) || parser.peek_keyword(Keyword::NEXT) =>
             {
@@ -301,6 +349,24 @@ impl Dialect for SnowflakeDialect {
     fn supports_timestamp_versioning(&self) -> bool {
         true
     }
+
+    /// See: <https://docs.snowflake.com/en/sql-reference/constructs/group-by>
+    fn supports_group_by_expr(&self) -> bool {
+        true
+    }
+
+    /// See: <https://docs.snowflake.com/en/sql-reference/constructs/connect-by>
+    fn get_reserved_keywords_for_select_item_operator(&self) -> &[Keyword] {
+        &RESERVED_KEYWORDS_FOR_SELECT_ITEM_OPERATOR
+    }
+
+    fn supports_space_separated_column_options(&self) -> bool {
+        true
+    }
+
+    fn supports_comma_separated_drop_column_list(&self) -> bool {
+        true
+    }
 }
 
 fn parse_file_staging_command(kw: Keyword, parser: &mut Parser) -> Result<Statement, ParserError> {
@@ -323,14 +389,28 @@ fn parse_file_staging_command(kw: Keyword, parser: &mut Parser) -> Result<Statem
     }
 }
 
+/// Parse snowflake alter session.
+/// <https://docs.snowflake.com/en/sql-reference/sql/alter-session>
+fn parse_alter_session(parser: &mut Parser, set: bool) -> Result<Statement, ParserError> {
+    let session_options = parse_session_options(parser, set)?;
+    Ok(Statement::AlterSession {
+        set,
+        session_params: KeyValueOptions {
+            options: session_options,
+        },
+    })
+}
+
 /// Parse snowflake create table statement.
 /// <https://docs.snowflake.com/en/sql-reference/sql/create-table>
+/// <https://docs.snowflake.com/en/sql-reference/sql/create-iceberg-table>
 pub fn parse_create_table(
     or_replace: bool,
     global: Option<bool>,
     temporary: bool,
     volatile: bool,
     transient: bool,
+    iceberg: bool,
     parser: &mut Parser,
 ) -> Result<Statement, ParserError> {
     let if_not_exists = parser.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]);
@@ -342,6 +422,7 @@ pub fn parse_create_table(
         .temporary(temporary)
         .transient(transient)
         .volatile(volatile)
+        .iceberg(iceberg)
         .global(global)
         .hive_formats(Some(Default::default()));
 
@@ -351,6 +432,8 @@ pub fn parse_create_table(
     // "CREATE TABLE x COPY GRANTS (c INT)" and "CREATE TABLE x (c INT) COPY GRANTS" are both
     // accepted by Snowflake
 
+    let mut plain_options = vec![];
+
     loop {
         let next_token = parser.next_token();
         match &next_token.token {
@@ -362,7 +445,9 @@ pub fn parse_create_table(
                 Keyword::COMMENT => {
                     // Rewind the COMMENT keyword
                     parser.prev_token();
-                    builder = builder.comment(parser.parse_optional_inline_comment()?);
+                    if let Some(comment_def) = parser.parse_optional_inline_comment()? {
+                        plain_options.push(SqlOption::Comment(comment_def))
+                    }
                 }
                 Keyword::AS => {
                     let query = parser.parse_query()?;
@@ -383,7 +468,7 @@ pub fn parse_create_table(
                     parser.expect_keyword_is(Keyword::BY)?;
                     parser.expect_token(&Token::LParen)?;
                     let cluster_by = Some(WrappedCollection::Parentheses(
-                        parser.parse_comma_separated(|p| p.parse_identifier())?,
+                        parser.parse_comma_separated(|p| p.parse_expr())?,
                     ));
                     parser.expect_token(&Token::RParen)?;
 
@@ -468,6 +553,31 @@ pub fn parse_create_table(
                     let on_commit = Some(parser.parse_create_table_on_commit()?);
                     builder = builder.on_commit(on_commit);
                 }
+                Keyword::EXTERNAL_VOLUME => {
+                    parser.expect_token(&Token::Eq)?;
+                    builder.external_volume = Some(parser.parse_literal_string()?);
+                }
+                Keyword::CATALOG => {
+                    parser.expect_token(&Token::Eq)?;
+                    builder.catalog = Some(parser.parse_literal_string()?);
+                }
+                Keyword::BASE_LOCATION => {
+                    parser.expect_token(&Token::Eq)?;
+                    builder.base_location = Some(parser.parse_literal_string()?);
+                }
+                Keyword::CATALOG_SYNC => {
+                    parser.expect_token(&Token::Eq)?;
+                    builder.catalog_sync = Some(parser.parse_literal_string()?);
+                }
+                Keyword::STORAGE_SERIALIZATION_POLICY => {
+                    parser.expect_token(&Token::Eq)?;
+
+                    builder.storage_serialization_policy =
+                        Some(parse_storage_serialization_policy(parser)?);
+                }
+                Keyword::IF if parser.parse_keywords(&[Keyword::NOT, Keyword::EXISTS]) => {
+                    builder = builder.if_not_exists(true);
+                }
                 _ => {
                     return parser.expected("end of statement", next_token);
                 }
@@ -501,10 +611,37 @@ pub fn parse_create_table(
             }
         }
     }
+    let table_options = if !plain_options.is_empty() {
+        crate::ast::CreateTableOptions::Plain(plain_options)
+    } else {
+        crate::ast::CreateTableOptions::None
+    };
+
+    builder = builder.table_options(table_options);
+
+    if iceberg && builder.base_location.is_none() {
+        return Err(ParserError::ParserError(
+            "BASE_LOCATION is required for ICEBERG tables".to_string(),
+        ));
+    }
 
     Ok(builder.build())
 }
 
+pub fn parse_storage_serialization_policy(
+    parser: &mut Parser,
+) -> Result<StorageSerializationPolicy, ParserError> {
+    let next_token = parser.next_token();
+    match &next_token.token {
+        Token::Word(w) => match w.keyword {
+            Keyword::COMPATIBLE => Ok(StorageSerializationPolicy::Compatible),
+            Keyword::OPTIMIZED => Ok(StorageSerializationPolicy::Optimized),
+            _ => parser.expected("storage_serialization_policy", next_token),
+        },
+        _ => parser.expected("storage_serialization_policy", next_token),
+    }
+}
+
 pub fn parse_create_stage(
     or_replace: bool,
     temporary: bool,
@@ -542,10 +679,7 @@ pub fn parse_create_stage(
     // [ comment ]
     if parser.parse_keyword(Keyword::COMMENT) {
         parser.expect_token(&Token::Eq)?;
-        comment = Some(match parser.next_token().token {
-            Token::SingleQuotedString(word) => Ok(word),
-            _ => parser.expected("a comment statement", parser.peek_token()),
-        }?)
+        comment = Some(parser.parse_comment_value()?);
     }
 
     Ok(Statement::CreateStage {
@@ -554,13 +688,13 @@ pub fn parse_create_stage(
         if_not_exists,
         name,
         stage_params,
-        directory_table_params: DataLoadingOptions {
+        directory_table_params: KeyValueOptions {
             options: directory_table_params,
         },
-        file_format: DataLoadingOptions {
+        file_format: KeyValueOptions {
             options: file_format,
         },
-        copy_options: DataLoadingOptions {
+        copy_options: KeyValueOptions {
             options: copy_options,
         },
         comment,
@@ -571,7 +705,7 @@ pub fn parse_stage_name_identifier(parser: &mut Parser) -> Result<Ident, ParserE
     let mut ident = String::new();
     while let Some(next_token) = parser.next_token_no_skip() {
         match &next_token.token {
-            Token::Whitespace(_) => break,
+            Token::Whitespace(_) | Token::SemiColon => break,
             Token::Period => {
                 parser.prev_token();
                 break;
@@ -602,7 +736,7 @@ pub fn parse_snowflake_stage_name(parser: &mut Parser) -> Result<ObjectName, Par
                     break;
                 }
             }
-            Ok(ObjectName(idents))
+            Ok(ObjectName::from(idents))
         }
         _ => {
             parser.prev_token();
@@ -611,40 +745,70 @@ pub fn parse_snowflake_stage_name(parser: &mut Parser) -> Result<ObjectName, Par
     }
 }
 
+/// Parses a `COPY INTO` statement. Snowflake has two variants, `COPY INTO <table>`
+/// and `COPY INTO <location>` which have different syntax.
 pub fn parse_copy_into(parser: &mut Parser) -> Result<Statement, ParserError> {
-    let into: ObjectName = parse_snowflake_stage_name(parser)?;
+    let kind = match parser.peek_token().token {
+        // Indicates an internal stage
+        Token::AtSign => CopyIntoSnowflakeKind::Location,
+        // Indicates an external stage, i.e. s3://, gcs:// or azure://
+        Token::SingleQuotedString(s) if s.contains("://") => CopyIntoSnowflakeKind::Location,
+        _ => CopyIntoSnowflakeKind::Table,
+    };
+
     let mut files: Vec<String> = vec![];
-    let mut from_transformations: Option<Vec<StageLoadSelectItem>> = None;
-    let from_stage_alias;
-    let from_stage: ObjectName;
-    let stage_params: StageParamsObject;
+    let mut from_transformations: Option<Vec<StageLoadSelectItemKind>> = None;
+    let mut from_stage_alias = None;
+    let mut from_stage = None;
+    let mut stage_params = StageParamsObject {
+        url: None,
+        encryption: KeyValueOptions { options: vec![] },
+        endpoint: None,
+        storage_integration: None,
+        credentials: KeyValueOptions { options: vec![] },
+    };
+    let mut from_query = None;
+    let mut partition = None;
+    let mut file_format = Vec::new();
+    let mut pattern = None;
+    let mut validation_mode = None;
+    let mut copy_options = Vec::new();
+
+    let into: ObjectName = parse_snowflake_stage_name(parser)?;
+    if kind == CopyIntoSnowflakeKind::Location {
+        stage_params = parse_stage_params(parser)?;
+    }
+
+    let into_columns = match &parser.peek_token().token {
+        Token::LParen => Some(parser.parse_parenthesized_column_list(IsOptional::Optional, true)?),
+        _ => None,
+    };
 
     parser.expect_keyword_is(Keyword::FROM)?;
-    // check if data load transformations are present
     match parser.next_token().token {
-        Token::LParen => {
-            // data load with transformations
+        Token::LParen if kind == CopyIntoSnowflakeKind::Table => {
+            // Data load with transformations
             parser.expect_keyword_is(Keyword::SELECT)?;
             from_transformations = parse_select_items_for_data_load(parser)?;
 
             parser.expect_keyword_is(Keyword::FROM)?;
-            from_stage = parse_snowflake_stage_name(parser)?;
+            from_stage = Some(parse_snowflake_stage_name(parser)?);
             stage_params = parse_stage_params(parser)?;
 
-            // as
-            from_stage_alias = if parser.parse_keyword(Keyword::AS) {
-                Some(match parser.next_token().token {
-                    Token::Word(w) => Ok(Ident::new(w.value)),
-                    _ => parser.expected("stage alias", parser.peek_token()),
-                }?)
-            } else {
-                None
-            };
+            // Parse an optional alias
+            from_stage_alias = parser
+                .maybe_parse_table_alias()?
+                .map(|table_alias| table_alias.name);
+            parser.expect_token(&Token::RParen)?;
+        }
+        Token::LParen if kind == CopyIntoSnowflakeKind::Location => {
+            // Data unload with a query
+            from_query = Some(parser.parse_query()?);
             parser.expect_token(&Token::RParen)?;
         }
         _ => {
             parser.prev_token();
-            from_stage = parse_snowflake_stage_name(parser)?;
+            from_stage = Some(parse_snowflake_stage_name(parser)?);
             stage_params = parse_stage_params(parser)?;
 
             // as
@@ -657,167 +821,180 @@ pub fn parse_copy_into(parser: &mut Parser) -> Result<Statement, ParserError> {
                 None
             };
         }
-    };
+    }
 
-    // [ files ]
-    if parser.parse_keyword(Keyword::FILES) {
-        parser.expect_token(&Token::Eq)?;
-        parser.expect_token(&Token::LParen)?;
-        let mut continue_loop = true;
-        while continue_loop {
-            continue_loop = false;
+    loop {
+        // FILE_FORMAT
+        if parser.parse_keyword(Keyword::FILE_FORMAT) {
+            parser.expect_token(&Token::Eq)?;
+            file_format = parse_parentheses_options(parser)?;
+        // PARTITION BY
+        } else if parser.parse_keywords(&[Keyword::PARTITION, Keyword::BY]) {
+            partition = Some(Box::new(parser.parse_expr()?))
+        // FILES
+        } else if parser.parse_keyword(Keyword::FILES) {
+            parser.expect_token(&Token::Eq)?;
+            parser.expect_token(&Token::LParen)?;
+            let mut continue_loop = true;
+            while continue_loop {
+                continue_loop = false;
+                let next_token = parser.next_token();
+                match next_token.token {
+                    Token::SingleQuotedString(s) => files.push(s),
+                    _ => parser.expected("file token", next_token)?,
+                };
+                if parser.next_token().token.eq(&Token::Comma) {
+                    continue_loop = true;
+                } else {
+                    parser.prev_token(); // not a comma, need to go back
+                }
+            }
+            parser.expect_token(&Token::RParen)?;
+        // PATTERN
+        } else if parser.parse_keyword(Keyword::PATTERN) {
+            parser.expect_token(&Token::Eq)?;
             let next_token = parser.next_token();
-            match next_token.token {
-                Token::SingleQuotedString(s) => files.push(s),
-                _ => parser.expected("file token", next_token)?,
-            };
-            if parser.next_token().token.eq(&Token::Comma) {
-                continue_loop = true;
-            } else {
-                parser.prev_token(); // not a comma, need to go back
+            pattern = Some(match next_token.token {
+                Token::SingleQuotedString(s) => s,
+                _ => parser.expected("pattern", next_token)?,
+            });
+        // VALIDATION MODE
+        } else if parser.parse_keyword(Keyword::VALIDATION_MODE) {
+            parser.expect_token(&Token::Eq)?;
+            validation_mode = Some(parser.next_token().token.to_string());
+        // COPY OPTIONS
+        } else if parser.parse_keyword(Keyword::COPY_OPTIONS) {
+            parser.expect_token(&Token::Eq)?;
+            copy_options = parse_parentheses_options(parser)?;
+        } else {
+            match parser.next_token().token {
+                Token::SemiColon | Token::EOF => break,
+                Token::Comma => continue,
+                // In `COPY INTO <location>` the copy options do not have a shared key
+                // like in `COPY INTO <table>`
+                Token::Word(key) => copy_options.push(parse_option(parser, key)?),
+                _ => return parser.expected("another copy option, ; or EOF'", parser.peek_token()),
             }
         }
-        parser.expect_token(&Token::RParen)?;
-    }
-
-    // [ pattern ]
-    let mut pattern = None;
-    if parser.parse_keyword(Keyword::PATTERN) {
-        parser.expect_token(&Token::Eq)?;
-        let next_token = parser.next_token();
-        pattern = Some(match next_token.token {
-            Token::SingleQuotedString(s) => s,
-            _ => parser.expected("pattern", next_token)?,
-        });
-    }
-
-    // [ file_format]
-    let mut file_format = Vec::new();
-    if parser.parse_keyword(Keyword::FILE_FORMAT) {
-        parser.expect_token(&Token::Eq)?;
-        file_format = parse_parentheses_options(parser)?;
-    }
-
-    // [ copy_options ]
-    let mut copy_options = Vec::new();
-    if parser.parse_keyword(Keyword::COPY_OPTIONS) {
-        parser.expect_token(&Token::Eq)?;
-        copy_options = parse_parentheses_options(parser)?;
-    }
-
-    // [ VALIDATION_MODE ]
-    let mut validation_mode = None;
-    if parser.parse_keyword(Keyword::VALIDATION_MODE) {
-        parser.expect_token(&Token::Eq)?;
-        validation_mode = Some(parser.next_token().token.to_string());
     }
 
     Ok(Statement::CopyIntoSnowflake {
+        kind,
         into,
-        from_stage,
-        from_stage_alias,
+        into_columns,
+        from_obj: from_stage,
+        from_obj_alias: from_stage_alias,
         stage_params,
         from_transformations,
+        from_query,
         files: if files.is_empty() { None } else { Some(files) },
         pattern,
-        file_format: DataLoadingOptions {
+        file_format: KeyValueOptions {
             options: file_format,
         },
-        copy_options: DataLoadingOptions {
+        copy_options: KeyValueOptions {
             options: copy_options,
         },
         validation_mode,
+        partition,
     })
 }
 
 fn parse_select_items_for_data_load(
     parser: &mut Parser,
-) -> Result<Option<Vec<StageLoadSelectItem>>, ParserError> {
-    // [<alias>.]$<file_col_num>[.<element>] [ , [<alias>.]$<file_col_num>[.<element>] ... ]
-    let mut select_items: Vec<StageLoadSelectItem> = vec![];
+) -> Result<Option<Vec<StageLoadSelectItemKind>>, ParserError> {
+    let mut select_items: Vec<StageLoadSelectItemKind> = vec![];
     loop {
-        let mut alias: Option<Ident> = None;
-        let mut file_col_num: i32 = 0;
-        let mut element: Option<Ident> = None;
-        let mut item_as: Option<Ident> = None;
+        match parser.maybe_parse(parse_select_item_for_data_load)? {
+            // [<alias>.]$<file_col_num>[.<element>] [ , [<alias>.]$<file_col_num>[.<element>] ... ]
+            Some(item) => select_items.push(StageLoadSelectItemKind::StageLoadSelectItem(item)),
+            // Fallback, try to parse a standard SQL select item
+            None => select_items.push(StageLoadSelectItemKind::SelectItem(
+                parser.parse_select_item()?,
+            )),
+        }
+        if matches!(parser.peek_token_ref().token, Token::Comma) {
+            parser.advance_token();
+        } else {
+            break;
+        }
+    }
+    Ok(Some(select_items))
+}
 
-        let next_token = parser.next_token();
-        match next_token.token {
+fn parse_select_item_for_data_load(
+    parser: &mut Parser,
+) -> Result<StageLoadSelectItem, ParserError> {
+    let mut alias: Option<Ident> = None;
+    let mut file_col_num: i32 = 0;
+    let mut element: Option<Ident> = None;
+    let mut item_as: Option<Ident> = None;
+
+    let next_token = parser.next_token();
+    match next_token.token {
+        Token::Placeholder(w) => {
+            file_col_num = w.to_string().split_off(1).parse::<i32>().map_err(|e| {
+                ParserError::ParserError(format!("Could not parse '{w}' as i32: {e}"))
+            })?;
+            Ok(())
+        }
+        Token::Word(w) => {
+            alias = Some(Ident::new(w.value));
+            Ok(())
+        }
+        _ => parser.expected("alias or file_col_num", next_token),
+    }?;
+
+    if alias.is_some() {
+        parser.expect_token(&Token::Period)?;
+        // now we get col_num token
+        let col_num_token = parser.next_token();
+        match col_num_token.token {
             Token::Placeholder(w) => {
                 file_col_num = w.to_string().split_off(1).parse::<i32>().map_err(|e| {
                     ParserError::ParserError(format!("Could not parse '{w}' as i32: {e}"))
                 })?;
                 Ok(())
             }
-            Token::Word(w) => {
-                alias = Some(Ident::new(w.value));
-                Ok(())
-            }
-            _ => parser.expected("alias or file_col_num", next_token),
+            _ => parser.expected("file_col_num", col_num_token),
         }?;
+    }
 
-        if alias.is_some() {
-            parser.expect_token(&Token::Period)?;
-            // now we get col_num token
-            let col_num_token = parser.next_token();
-            match col_num_token.token {
-                Token::Placeholder(w) => {
-                    file_col_num = w.to_string().split_off(1).parse::<i32>().map_err(|e| {
-                        ParserError::ParserError(format!("Could not parse '{w}' as i32: {e}"))
-                    })?;
-                    Ok(())
-                }
-                _ => parser.expected("file_col_num", col_num_token),
-            }?;
+    // try extracting optional element
+    match parser.next_token().token {
+        Token::Colon => {
+            // parse element
+            element = Some(Ident::new(match parser.next_token().token {
+                Token::Word(w) => Ok(w.value),
+                _ => parser.expected("file_col_num", parser.peek_token()),
+            }?));
         }
-
-        // try extracting optional element
-        match parser.next_token().token {
-            Token::Colon => {
-                // parse element
-                element = Some(Ident::new(match parser.next_token().token {
-                    Token::Word(w) => Ok(w.value),
-                    _ => parser.expected("file_col_num", parser.peek_token()),
-                }?));
-            }
-            _ => {
-                // element not present move back
-                parser.prev_token();
-            }
-        }
-
-        // as
-        if parser.parse_keyword(Keyword::AS) {
-            item_as = Some(match parser.next_token().token {
-                Token::Word(w) => Ok(Ident::new(w.value)),
-                _ => parser.expected("column item alias", parser.peek_token()),
-            }?);
-        }
-
-        select_items.push(StageLoadSelectItem {
-            alias,
-            file_col_num,
-            element,
-            item_as,
-        });
-
-        match parser.next_token().token {
-            Token::Comma => {
-                // continue
-            }
-            _ => {
-                parser.prev_token(); // need to move back
-                break;
-            }
+        _ => {
+            // element not present move back
+            parser.prev_token();
         }
     }
-    Ok(Some(select_items))
+
+    // as
+    if parser.parse_keyword(Keyword::AS) {
+        item_as = Some(match parser.next_token().token {
+            Token::Word(w) => Ok(Ident::new(w.value)),
+            _ => parser.expected("column item alias", parser.peek_token()),
+        }?);
+    }
+
+    Ok(StageLoadSelectItem {
+        alias,
+        file_col_num,
+        element,
+        item_as,
+    })
 }
 
 fn parse_stage_params(parser: &mut Parser) -> Result<StageParamsObject, ParserError> {
     let (mut url, mut storage_integration, mut endpoint) = (None, None, None);
-    let mut encryption: DataLoadingOptions = DataLoadingOptions { options: vec![] };
-    let mut credentials: DataLoadingOptions = DataLoadingOptions { options: vec![] };
+    let mut encryption: KeyValueOptions = KeyValueOptions { options: vec![] };
+    let mut credentials: KeyValueOptions = KeyValueOptions { options: vec![] };
 
     // URL
     if parser.parse_keyword(Keyword::URL) {
@@ -846,7 +1023,7 @@ fn parse_stage_params(parser: &mut Parser) -> Result<StageParamsObject, ParserEr
     // CREDENTIALS
     if parser.parse_keyword(Keyword::CREDENTIALS) {
         parser.expect_token(&Token::Eq)?;
-        credentials = DataLoadingOptions {
+        credentials = KeyValueOptions {
             options: parse_parentheses_options(parser)?,
         };
     }
@@ -854,7 +1031,7 @@ fn parse_stage_params(parser: &mut Parser) -> Result<StageParamsObject, ParserEr
     // ENCRYPTION
     if parser.parse_keyword(Keyword::ENCRYPTION) {
         parser.expect_token(&Token::Eq)?;
-        encryption = DataLoadingOptions {
+        encryption = KeyValueOptions {
             options: parse_parentheses_options(parser)?,
         };
     }
@@ -868,63 +1045,108 @@ fn parse_stage_params(parser: &mut Parser) -> Result<StageParamsObject, ParserEr
     })
 }
 
+/// Parses options separated by blank spaces, commas, or new lines like:
+/// ABORT_DETACHED_QUERY = { TRUE | FALSE }
+///      [ ACTIVE_PYTHON_PROFILER = { 'LINE' | 'MEMORY' } ]
+///      [ BINARY_INPUT_FORMAT = '\<string\>' ]
+fn parse_session_options(
+    parser: &mut Parser,
+    set: bool,
+) -> Result<Vec<KeyValueOption>, ParserError> {
+    let mut options: Vec<KeyValueOption> = Vec::new();
+    let empty = String::new;
+    loop {
+        let next_token = parser.peek_token();
+        match next_token.token {
+            Token::SemiColon | Token::EOF => break,
+            Token::Comma => {
+                parser.advance_token();
+                continue;
+            }
+            Token::Word(key) => {
+                parser.advance_token();
+                if set {
+                    let option = parse_option(parser, key)?;
+                    options.push(option);
+                } else {
+                    options.push(KeyValueOption {
+                        option_name: key.value,
+                        option_type: KeyValueOptionType::STRING,
+                        value: empty(),
+                    });
+                }
+            }
+            _ => {
+                return parser.expected("another option or end of statement", next_token);
+            }
+        }
+    }
+    if options.is_empty() {
+        Err(ParserError::ParserError(
+            "expected at least one option".to_string(),
+        ))
+    } else {
+        Ok(options)
+    }
+}
+
 /// Parses options provided within parentheses like:
 /// ( ENABLE = { TRUE | FALSE }
 ///      [ AUTO_REFRESH = { TRUE | FALSE } ]
 ///      [ REFRESH_ON_CREATE =  { TRUE | FALSE } ]
 ///      [ NOTIFICATION_INTEGRATION = '<notification_integration_name>' ] )
 ///
-fn parse_parentheses_options(parser: &mut Parser) -> Result<Vec<DataLoadingOption>, ParserError> {
-    let mut options: Vec<DataLoadingOption> = Vec::new();
-
+fn parse_parentheses_options(parser: &mut Parser) -> Result<Vec<KeyValueOption>, ParserError> {
+    let mut options: Vec<KeyValueOption> = Vec::new();
     parser.expect_token(&Token::LParen)?;
     loop {
         match parser.next_token().token {
             Token::RParen => break,
-            Token::Word(key) => {
-                parser.expect_token(&Token::Eq)?;
-                if parser.parse_keyword(Keyword::TRUE) {
-                    options.push(DataLoadingOption {
-                        option_name: key.value,
-                        option_type: DataLoadingOptionType::BOOLEAN,
-                        value: "TRUE".to_string(),
-                    });
-                    Ok(())
-                } else if parser.parse_keyword(Keyword::FALSE) {
-                    options.push(DataLoadingOption {
-                        option_name: key.value,
-                        option_type: DataLoadingOptionType::BOOLEAN,
-                        value: "FALSE".to_string(),
-                    });
-                    Ok(())
-                } else {
-                    match parser.next_token().token {
-                        Token::SingleQuotedString(value) => {
-                            options.push(DataLoadingOption {
-                                option_name: key.value,
-                                option_type: DataLoadingOptionType::STRING,
-                                value,
-                            });
-                            Ok(())
-                        }
-                        Token::Word(word) => {
-                            options.push(DataLoadingOption {
-                                option_name: key.value,
-                                option_type: DataLoadingOptionType::ENUM,
-                                value: word.value,
-                            });
-                            Ok(())
-                        }
-                        _ => parser.expected("expected option value", parser.peek_token()),
-                    }
-                }
-            }
-            _ => parser.expected("another option or ')'", parser.peek_token()),
-        }?;
+            Token::Comma => continue,
+            Token::Word(key) => options.push(parse_option(parser, key)?),
+            _ => return parser.expected("another option or ')'", parser.peek_token()),
+        };
     }
     Ok(options)
 }
 
+/// Parses a `KEY = VALUE` construct based on the specified key
+fn parse_option(parser: &mut Parser, key: Word) -> Result<KeyValueOption, ParserError> {
+    parser.expect_token(&Token::Eq)?;
+    if parser.parse_keyword(Keyword::TRUE) {
+        Ok(KeyValueOption {
+            option_name: key.value,
+            option_type: KeyValueOptionType::BOOLEAN,
+            value: "TRUE".to_string(),
+        })
+    } else if parser.parse_keyword(Keyword::FALSE) {
+        Ok(KeyValueOption {
+            option_name: key.value,
+            option_type: KeyValueOptionType::BOOLEAN,
+            value: "FALSE".to_string(),
+        })
+    } else {
+        match parser.next_token().token {
+            Token::SingleQuotedString(value) => Ok(KeyValueOption {
+                option_name: key.value,
+                option_type: KeyValueOptionType::STRING,
+                value,
+            }),
+            Token::Word(word) => Ok(KeyValueOption {
+                option_name: key.value,
+                option_type: KeyValueOptionType::ENUM,
+                value: word.value,
+            }),
+            Token::Number(n, _) => Ok(KeyValueOption {
+                option_name: key.value,
+                option_type: KeyValueOptionType::NUMBER,
+                value: n,
+            }),
+            _ => parser.expected("expected option value", parser.peek_token()),
+        }
+    }
+}
+
 /// Parsing a property of identity or autoincrement column option
 /// Syntax:
 /// ```sql
@@ -970,7 +1192,7 @@ fn parse_column_policy_property(
     parser: &mut Parser,
     with: bool,
 ) -> Result<ColumnPolicyProperty, ParserError> {
-    let policy_name = parser.parse_identifier()?;
+    let policy_name = parser.parse_object_name(false)?;
     let using_columns = if parser.parse_keyword(Keyword::USING) {
         parser.expect_token(&Token::LParen)?;
         let columns = parser.parse_comma_separated(|p| p.parse_identifier())?;
@@ -1000,3 +1222,13 @@ fn parse_column_tags(parser: &mut Parser, with: bool) -> Result<TagsColumnOption
 
     Ok(TagsColumnOption { with, tags })
 }
+
+/// Parse snowflake show objects.
+/// <https://docs.snowflake.com/en/sql-reference/sql/show-objects>
+fn parse_show_objects(terse: bool, parser: &mut Parser) -> Result<Statement, ParserError> {
+    let show_options = parser.parse_show_stmt_options()?;
+    Ok(Statement::ShowObjects(ShowObjects {
+        terse,
+        show_options,
+    }))
+}

src/dialect/sqlite.rs

@@ -15,7 +15,11 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::ast::Statement;
+#[cfg(not(feature = "std"))]
+use alloc::boxed::Box;
+
+use crate::ast::BinaryOperator;
+use crate::ast::{Expr, Statement};
 use crate::dialect::Dialect;
 use crate::keywords::Keyword;
 use crate::parser::{Parser, ParserError};
@@ -70,6 +74,27 @@ impl Dialect for SQLiteDialect {
         }
     }
 
+    fn parse_infix(
+        &self,
+        parser: &mut crate::parser::Parser,
+        expr: &crate::ast::Expr,
+        _precedence: u8,
+    ) -> Option<Result<crate::ast::Expr, ParserError>> {
+        // Parse MATCH and REGEXP as operators
+        // See <https://www.sqlite.org/lang_expr.html#the_like_glob_regexp_match_and_extract_operators>
+        for (keyword, op) in [
+            (Keyword::REGEXP, BinaryOperator::Regexp),
+            (Keyword::MATCH, BinaryOperator::Match),
+        ] {
+            if parser.parse_keyword(keyword) {
+                let left = Box::new(expr.clone());
+                let right = Box::new(parser.parse_expr().unwrap());
+                return Some(Ok(Expr::BinaryOp { left, op, right }));
+            }
+        }
+        None
+    }
+
     fn supports_in_empty_list(&self) -> bool {
         true
     }

src/display_utils.rs

@@ -0,0 +1,135 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+//! Utilities for formatting SQL AST nodes with pretty printing support.
+//!
+//! The module provides formatters that implement the `Display` trait with support
+//! for both regular (`{}`) and pretty (`{:#}`) formatting modes. Pretty printing
+//! adds proper indentation and line breaks to make SQL statements more readable.
+
+use core::fmt::{self, Display, Write};
+
+/// A wrapper around a value that adds an indent to the value when displayed with {:#}.
+pub(crate) struct Indent<T>(pub T);
+
+const INDENT: &str = "  ";
+
+impl<T> Display for Indent<T>
+where
+    T: Display,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if f.alternate() {
+            f.write_str(INDENT)?;
+            write!(Indent(f), "{:#}", self.0)
+        } else {
+            self.0.fmt(f)
+        }
+    }
+}
+
+/// Adds an indent to the inner writer
+impl<T> Write for Indent<T>
+where
+    T: Write,
+{
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        self.0.write_str(s)?;
+        // Our NewLine and SpaceOrNewline utils always print individual newlines as a single-character string.
+        if s == "\n" {
+            self.0.write_str(INDENT)?;
+        }
+        Ok(())
+    }
+}
+
+/// A value that inserts a newline when displayed with {:#}, but not when displayed with {}.
+pub(crate) struct NewLine;
+
+impl Display for NewLine {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if f.alternate() {
+            f.write_char('\n')
+        } else {
+            Ok(())
+        }
+    }
+}
+
+/// A value that inserts a space when displayed with {}, but a newline when displayed with {:#}.
+pub(crate) struct SpaceOrNewline;
+
+impl Display for SpaceOrNewline {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if f.alternate() {
+            f.write_char('\n')
+        } else {
+            f.write_char(' ')
+        }
+    }
+}
+
+/// A value that displays a comma-separated list of values.
+/// When pretty-printed (using {:#}), it displays each value on a new line.
+pub(crate) struct DisplayCommaSeparated<'a, T: fmt::Display>(pub(crate) &'a [T]);
+
+impl<T: fmt::Display> fmt::Display for DisplayCommaSeparated<'_, T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let mut first = true;
+        for t in self.0 {
+            if !first {
+                f.write_char(',')?;
+                SpaceOrNewline.fmt(f)?;
+            }
+            first = false;
+            t.fmt(f)?;
+        }
+        Ok(())
+    }
+}
+
+/// Displays a whitespace, followed by a comma-separated list that is indented when pretty-printed.
+pub(crate) fn indented_list<T: fmt::Display>(f: &mut fmt::Formatter, items: &[T]) -> fmt::Result {
+    SpaceOrNewline.fmt(f)?;
+    Indent(DisplayCommaSeparated(items)).fmt(f)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_indent() {
+        struct TwoLines;
+
+        impl Display for TwoLines {
+            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                f.write_str("line 1")?;
+                SpaceOrNewline.fmt(f)?;
+                f.write_str("line 2")
+            }
+        }
+
+        let indent = Indent(TwoLines);
+        assert_eq!(
+            indent.to_string(),
+            TwoLines.to_string(),
+            "Only the alternate form should be indented"
+        );
+        assert_eq!(format!("{:#}", indent), "  line 1\n  line 2");
+    }
+}

src/keywords.rs

@@ -18,14 +18,14 @@
 //! This module defines
 //! 1) a list of constants for every keyword
 //! 2) an `ALL_KEYWORDS` array with every keyword in it
-//!     This is not a list of *reserved* keywords: some of these can be
-//!     parsed as identifiers if the parser decides so. This means that
-//!     new keywords can be added here without affecting the parse result.
+//!    This is not a list of *reserved* keywords: some of these can be
+//!    parsed as identifiers if the parser decides so. This means that
+//!    new keywords can be added here without affecting the parse result.
 //!
-//!     As a matter of fact, most of these keywords are not used at all
-//!     and could be removed.
+//!    As a matter of fact, most of these keywords are not used at all
+//!    and could be removed.
 //! 3) a `RESERVED_FOR_TABLE_ALIAS` array with keywords reserved in a
-//!     "table alias" context.
+//!    "table alias" context.
 
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
@@ -83,7 +83,9 @@ define_keywords!(
     ADMIN,
     AFTER,
     AGAINST,
+    AGGREGATE,
     AGGREGATION,
+    ALERT,
     ALGORITHM,
     ALIAS,
     ALL,
@@ -96,6 +98,7 @@ define_keywords!(
     ANY,
     APPLICATION,
     APPLY,
+    APPLYBUDGET,
     ARCHIVE,
     ARE,
     ARRAY,
@@ -109,14 +112,19 @@ define_keywords!(
     AT,
     ATOMIC,
     ATTACH,
+    AUDIT,
+    AUTHENTICATION,
     AUTHORIZATION,
     AUTO,
+    AUTOEXTEND_SIZE,
     AUTOINCREMENT,
     AUTO_INCREMENT,
     AVG,
+    AVG_ROW_LENGTH,
     AVRO,
     BACKWARD,
     BASE64,
+    BASE_LOCATION,
     BEFORE,
     BEGIN,
     BEGIN_FRAME,
@@ -127,14 +135,18 @@ define_keywords!(
     BIGINT,
     BIGNUMERIC,
     BINARY,
+    BIND,
     BINDING,
     BIT,
     BLOB,
     BLOCK,
+    BLOOM,
     BLOOMFILTER,
     BOOL,
     BOOLEAN,
     BOTH,
+    BOX,
+    BRIN,
     BROWSE,
     BTREE,
     BUCKET,
@@ -150,8 +162,10 @@ define_keywords!(
     CASCADE,
     CASCADED,
     CASE,
+    CASES,
     CAST,
     CATALOG,
+    CATALOG_SYNC,
     CATCH,
     CEIL,
     CEILING,
@@ -162,11 +176,14 @@ define_keywords!(
     CHANNEL,
     CHAR,
     CHARACTER,
+    CHARACTERISTICS,
     CHARACTERS,
     CHARACTER_LENGTH,
     CHARSET,
     CHAR_LENGTH,
     CHECK,
+    CHECKSUM,
+    CIRCLE,
     CLEAR,
     CLOB,
     CLONE,
@@ -185,6 +202,7 @@ define_keywords!(
     COMMENT,
     COMMIT,
     COMMITTED,
+    COMPATIBLE,
     COMPRESSION,
     COMPUTE,
     CONCURRENTLY,
@@ -192,6 +210,8 @@ define_keywords!(
     CONFLICT,
     CONNECT,
     CONNECTION,
+    CONNECTOR,
+    CONNECT_BY_ROOT,
     CONSTRAINT,
     CONTAINS,
     CONTINUE,
@@ -237,6 +257,7 @@ define_keywords!(
     DAYOFWEEK,
     DAYOFYEAR,
     DAYS,
+    DCPROPERTIES,
     DEALLOCATE,
     DEC,
     DECADE,
@@ -251,11 +272,13 @@ define_keywords!(
     DEFINED,
     DEFINER,
     DELAYED,
+    DELAY_KEY_WRITE,
     DELETE,
     DELIMITED,
     DELIMITER,
     DELTA,
     DENSE_RANK,
+    DENY,
     DEREF,
     DESC,
     DESCRIBE,
@@ -270,6 +293,7 @@ define_keywords!(
     DISTRIBUTE,
     DIV,
     DO,
+    DOMAIN,
     DOUBLE,
     DOW,
     DOY,
@@ -281,6 +305,7 @@ define_keywords!(
     ELEMENT,
     ELEMENTS,
     ELSE,
+    ELSEIF,
     EMPTY,
     ENABLE,
     ENABLE_SCHEMA_EVOLUTION,
@@ -293,6 +318,7 @@ define_keywords!(
     END_PARTITION,
     ENFORCED,
     ENGINE,
+    ENGINE_ATTRIBUTE,
     ENUM,
     ENUM16,
     ENUM8,
@@ -305,23 +331,29 @@ define_keywords!(
     ESTIMATE,
     EVENT,
     EVERY,
+    EVOLVE,
     EXCEPT,
     EXCEPTION,
+    EXCHANGE,
     EXCLUDE,
     EXCLUSIVE,
     EXEC,
     EXECUTE,
+    EXECUTION,
     EXISTS,
     EXP,
     EXPANSION,
     EXPLAIN,
     EXPLICIT,
     EXPORT,
+    EXTEND,
     EXTENDED,
     EXTENSION,
     EXTERNAL,
+    EXTERNAL_VOLUME,
     EXTRACT,
     FAIL,
+    FAILOVER,
     FALSE,
     FETCH,
     FIELDS,
@@ -357,16 +389,20 @@ define_keywords!(
     FREEZE,
     FROM,
     FSCK,
+    FULFILLMENT,
     FULL,
     FULLTEXT,
     FUNCTION,
     FUNCTIONS,
     FUSION,
+    FUTURE,
     GENERAL,
     GENERATE,
     GENERATED,
     GEOGRAPHY,
     GET,
+    GIN,
+    GIST,
     GLOBAL,
     GRANT,
     GRANTED,
@@ -386,6 +422,8 @@ define_keywords!(
     HOSTS,
     HOUR,
     HOURS,
+    HUGEINT,
+    ICEBERG,
     ID,
     IDENTITY,
     IDENTITY_INSERT,
@@ -394,6 +432,8 @@ define_keywords!(
     ILIKE,
     IMMEDIATE,
     IMMUTABLE,
+    IMPORT,
+    IMPORTED,
     IN,
     INCLUDE,
     INCLUDE_NULL_VALUES,
@@ -401,15 +441,19 @@ define_keywords!(
     INDEX,
     INDICATOR,
     INHERIT,
+    INHERITS,
     INITIALLY,
     INNER,
     INOUT,
     INPATH,
+    INPLACE,
     INPUT,
     INPUTFORMAT,
     INSENSITIVE,
     INSERT,
+    INSERT_METHOD,
     INSTALL,
+    INSTANT,
     INSTEAD,
     INT,
     INT128,
@@ -421,6 +465,7 @@ define_keywords!(
     INT64,
     INT8,
     INTEGER,
+    INTEGRATION,
     INTERPOLATE,
     INTERSECT,
     INTERSECTION,
@@ -443,6 +488,7 @@ define_keywords!(
     JULIAN,
     KEY,
     KEYS,
+    KEY_BLOCK_SIZE,
     KILL,
     LAG,
     LANGUAGE,
@@ -457,9 +503,11 @@ define_keywords!(
     LIKE,
     LIKE_REGEX,
     LIMIT,
+    LINE,
     LINES,
     LIST,
     LISTEN,
+    LISTING,
     LN,
     LOAD,
     LOCAL,
@@ -477,7 +525,10 @@ define_keywords!(
     LOWER,
     LOW_PRIORITY,
     LS,
+    LSEG,
     MACRO,
+    MANAGE,
+    MANAGED,
     MANAGEDLOCATION,
     MAP,
     MASKING,
@@ -491,14 +542,17 @@ define_keywords!(
     MAX,
     MAXVALUE,
     MAX_DATA_EXTENSION_TIME_IN_DAYS,
+    MAX_ROWS,
     MEASURES,
     MEDIUMBLOB,
     MEDIUMINT,
     MEDIUMTEXT,
     MEMBER,
     MERGE,
+    MESSAGE,
     METADATA,
     METHOD,
+    METRIC,
     MICROSECOND,
     MICROSECONDS,
     MILLENIUM,
@@ -510,17 +564,20 @@ define_keywords!(
     MINUTE,
     MINUTES,
     MINVALUE,
+    MIN_ROWS,
     MOD,
     MODE,
     MODIFIES,
     MODIFY,
     MODULE,
+    MONITOR,
     MONTH,
     MONTHS,
     MSCK,
     MULTISET,
     MUTATION,
     NAME,
+    NAMES,
     NANOSECOND,
     NANOSECONDS,
     NATIONAL,
@@ -528,6 +585,7 @@ define_keywords!(
     NCHAR,
     NCLOB,
     NESTED,
+    NETWORK,
     NEW,
     NEXT,
     NFC,
@@ -561,6 +619,7 @@ define_keywords!(
     NUMERIC,
     NVARCHAR,
     OBJECT,
+    OBJECTS,
     OCCURRENCES_REGEX,
     OCTETS,
     OCTET_LENGTH,
@@ -575,8 +634,11 @@ define_keywords!(
     ONLY,
     OPEN,
     OPENJSON,
+    OPERATE,
     OPERATOR,
+    OPTIMIZATION,
     OPTIMIZE,
+    OPTIMIZED,
     OPTIMIZER_COSTS,
     OPTION,
     OPTIONS,
@@ -584,16 +646,24 @@ define_keywords!(
     ORC,
     ORDER,
     ORDINALITY,
+    ORGANIZATION,
+    OTHER,
     OUT,
     OUTER,
+    OUTPUT,
     OUTPUTFORMAT,
     OVER,
     OVERFLOW,
     OVERLAPS,
     OVERLAY,
+    OVERRIDE,
     OVERWRITE,
     OWNED,
     OWNER,
+    OWNERSHIP,
+    PACKAGE,
+    PACKAGES,
+    PACK_KEYS,
     PARALLEL,
     PARAMETER,
     PARQUET,
@@ -601,6 +671,7 @@ define_keywords!(
     PARTITION,
     PARTITIONED,
     PARTITIONS,
+    PASSING,
     PASSWORD,
     PAST,
     PATH,
@@ -617,7 +688,10 @@ define_keywords!(
     PLACING,
     PLAN,
     PLANS,
+    POINT,
     POLICY,
+    POLYGON,
+    POOL,
     PORTION,
     POSITION,
     POSITION_REGEX,
@@ -630,6 +704,7 @@ define_keywords!(
     PRESERVE,
     PREWHERE,
     PRIMARY,
+    PRINT,
     PRIOR,
     PRIVILEGES,
     PROCEDURE,
@@ -637,11 +712,13 @@ define_keywords!(
     PROGRAM,
     PROJECTION,
     PUBLIC,
+    PURCHASE,
     PURGE,
     QUALIFY,
     QUARTER,
     QUERY,
     QUOTE,
+    RAISE,
     RAISERROR,
     RANGE,
     RANK,
@@ -670,6 +747,7 @@ define_keywords!(
     RELATIVE,
     RELAY,
     RELEASE,
+    RELEASES,
     REMOTE,
     REMOVE,
     RENAME,
@@ -678,12 +756,16 @@ define_keywords!(
     REPEATABLE,
     REPLACE,
     REPLICA,
+    REPLICATE,
     REPLICATION,
     RESET,
+    RESOLVE,
+    RESOURCE,
     RESPECT,
     RESTART,
     RESTRICT,
     RESTRICTED,
+    RESTRICTIONS,
     RESTRICTIVE,
     RESULT,
     RESULTSET,
@@ -704,6 +786,7 @@ define_keywords!(
     ROW,
     ROWID,
     ROWS,
+    ROW_FORMAT,
     ROW_NUMBER,
     RULE,
     RUN,
@@ -718,6 +801,7 @@ define_keywords!(
     SEARCH,
     SECOND,
     SECONDARY,
+    SECONDARY_ENGINE_ATTRIBUTE,
     SECONDS,
     SECRET,
     SECURITY,
@@ -732,6 +816,8 @@ define_keywords!(
     SERDE,
     SERDEPROPERTIES,
     SERIALIZABLE,
+    SERVER,
+    SERVICE,
     SESSION,
     SESSION_USER,
     SET,
@@ -739,7 +825,10 @@ define_keywords!(
     SETS,
     SETTINGS,
     SHARE,
+    SHARED,
+    SHARING,
     SHOW,
+    SIGNED,
     SIMILAR,
     SKIP,
     SLOW,
@@ -752,11 +841,13 @@ define_keywords!(
     SPATIAL,
     SPECIFIC,
     SPECIFICTYPE,
+    SPGIST,
     SQL,
     SQLEXCEPTION,
     SQLSTATE,
     SQLWARNING,
     SQRT,
+    SRID,
     STABLE,
     STAGE,
     START,
@@ -764,24 +855,32 @@ define_keywords!(
     STATEMENT,
     STATIC,
     STATISTICS,
+    STATS_AUTO_RECALC,
+    STATS_PERSISTENT,
+    STATS_SAMPLE_PAGES,
     STATUS,
     STDDEV_POP,
     STDDEV_SAMP,
     STDIN,
     STDOUT,
     STEP,
+    STORAGE,
     STORAGE_INTEGRATION,
+    STORAGE_SERIALIZATION_POLICY,
     STORED,
+    STRAIGHT_JOIN,
     STRICT,
     STRING,
     STRUCT,
     SUBMULTISET,
+    SUBSTR,
     SUBSTRING,
     SUBSTRING_REGEX,
     SUCCEEDS,
     SUM,
     SUPER,
     SUPERUSER,
+    SUPPORT,
     SUSPEND,
     SWAP,
     SYMMETRIC,
@@ -792,8 +891,10 @@ define_keywords!(
     TABLE,
     TABLES,
     TABLESAMPLE,
+    TABLESPACE,
     TAG,
     TARGET,
+    TASK,
     TBLPROPERTIES,
     TEMP,
     TEMPORARY,
@@ -807,6 +908,7 @@ define_keywords!(
     TIME,
     TIMESTAMP,
     TIMESTAMPTZ,
+    TIMESTAMP_NTZ,
     TIMETZ,
     TIMEZONE,
     TIMEZONE_ABBR,
@@ -819,6 +921,7 @@ define_keywords!(
     TO,
     TOP,
     TOTALS,
+    TRACE,
     TRAILING,
     TRANSACTION,
     TRANSIENT,
@@ -834,9 +937,13 @@ define_keywords!(
     TRY,
     TRY_CAST,
     TRY_CONVERT,
+    TSQUERY,
+    TSVECTOR,
     TUPLE,
     TYPE,
+    UBIGINT,
     UESCAPE,
+    UHUGEINT,
     UINT128,
     UINT16,
     UINT256,
@@ -859,6 +966,7 @@ define_keywords!(
     UNNEST,
     UNPIVOT,
     UNSAFE,
+    UNSET,
     UNSIGNED,
     UNTIL,
     UPDATE,
@@ -869,14 +977,18 @@ define_keywords!(
     USER,
     USER_RESOURCES,
     USING,
+    USMALLINT,
+    UTINYINT,
     UUID,
     VACUUM,
     VALID,
+    VALIDATE,
     VALIDATION_MODE,
     VALUE,
     VALUES,
     VALUE_OF,
     VARBINARY,
+    VARBIT,
     VARCHAR,
     VARIABLES,
     VARYING,
@@ -885,16 +997,20 @@ define_keywords!(
     VERBOSE,
     VERSION,
     VERSIONING,
+    VERSIONS,
     VIEW,
     VIEWS,
     VIRTUAL,
     VOLATILE,
+    VOLUME,
     WAREHOUSE,
+    WAREHOUSES,
     WEEK,
     WEEKS,
     WHEN,
     WHENEVER,
     WHERE,
+    WHILE,
     WIDTH_BUCKET,
     WINDOW,
     WITH,
@@ -902,8 +1018,11 @@ define_keywords!(
     WITHOUT,
     WITHOUT_ARRAY_WRAPPER,
     WORK,
+    WRAPPER,
     WRITE,
     XML,
+    XMLNAMESPACES,
+    XMLTABLE,
     XOR,
     YEAR,
     YEARS,
@@ -952,6 +1071,8 @@ pub const RESERVED_FOR_TABLE_ALIAS: &[Keyword] = &[
     Keyword::ANTI,
     Keyword::SEMI,
     Keyword::RETURNING,
+    Keyword::ASOF,
+    Keyword::MATCH_CONDITION,
     // for MSSQL-specific OUTER APPLY (seems reserved in most dialects)
     Keyword::OUTER,
     Keyword::SET,
@@ -974,6 +1095,7 @@ pub const RESERVED_FOR_TABLE_ALIAS: &[Keyword] = &[
     Keyword::SAMPLE,
     Keyword::TABLESAMPLE,
     Keyword::FROM,
+    Keyword::OPEN,
 ];
 
 /// Can't be used as a column alias, so that `SELECT <expr> alias`
@@ -1008,7 +1130,7 @@ pub const RESERVED_FOR_COLUMN_ALIAS: &[Keyword] = &[
     Keyword::END,
 ];
 
-// Global list of reserved keywords alloweed after FROM.
+// Global list of reserved keywords allowed after FROM.
 // Parser should call Dialect::get_reserved_keyword_after_from
 // to allow for each dialect to customize the list.
 pub const RESERVED_FOR_TABLE_FACTOR: &[Keyword] = &[

src/lib.rs

@@ -64,6 +64,27 @@
 //! // The original SQL text can be generated from the AST
 //! assert_eq!(ast[0].to_string(), sql);
 //! ```
+//!
+//! # Pretty Printing
+//!
+//! SQL statements can be pretty-printed with proper indentation and line breaks using the alternate flag (`{:#}`):
+//!
+//! ```
+//! # use sqlparser::dialect::GenericDialect;
+//! # use sqlparser::parser::Parser;
+//! let sql = "SELECT a, b FROM table_1";
+//! let ast = Parser::parse_sql(&GenericDialect, sql).unwrap();
+//!
+//! // Pretty print with indentation and line breaks
+//! let pretty_sql = format!("{:#}", ast[0]);
+//! assert_eq!(pretty_sql, r#"
+//! SELECT
+//!   a,
+//!   b
+//! FROM
+//!   table_1
+//! "#.trim());
+//! ```
 //! [sqlparser crates.io page]: https://crates.io/crates/sqlparser
 //! [`Parser::parse_sql`]: crate::parser::Parser::parse_sql
 //! [`Parser::new`]: crate::parser::Parser::new
@@ -128,6 +149,10 @@
 
 #![cfg_attr(not(feature = "std"), no_std)]
 #![allow(clippy::upper_case_acronyms)]
+// Permit large enum variants to keep a unified, expressive AST.
+// Splitting complex nodes (expressions, statements, types) into separate types
+// would bloat the API and hide intent. Extra memory is a worthwhile tradeoff.
+#![allow(clippy::large_enum_variant)]
 
 // Allow proc-macros to find this crate
 extern crate self as sqlparser;
@@ -142,6 +167,7 @@ extern crate pretty_assertions;
 pub mod ast;
 #[macro_use]
 pub mod dialect;
+mod display_utils;
 pub mod keywords;
 pub mod parser;
 pub mod tokenizer;

src/parser/alter.rs

@@ -18,8 +18,8 @@ use alloc::vec;
 use super::{Parser, ParserError};
 use crate::{
     ast::{
-        AlterPolicyOperation, AlterRoleOperation, Expr, Password, ResetConfig, RoleOption,
-        SetConfigValue, Statement,
+        AlterConnectorOwner, AlterPolicyOperation, AlterRoleOperation, Expr, Password, ResetConfig,
+        RoleOption, SetConfigValue, Statement,
     },
     dialect::{MsSqlDialect, PostgreSqlDialect},
     keywords::Keyword,
@@ -99,6 +99,47 @@ impl Parser<'_> {
         }
     }
 
+    /// Parse an `ALTER CONNECTOR` statement
+    /// ```sql
+    /// ALTER CONNECTOR connector_name SET DCPROPERTIES(property_name=property_value, ...);
+    ///
+    /// ALTER CONNECTOR connector_name SET URL new_url;
+    ///
+    /// ALTER CONNECTOR connector_name SET OWNER [USER|ROLE] user_or_role;
+    /// ```
+    pub fn parse_alter_connector(&mut self) -> Result<Statement, ParserError> {
+        let name = self.parse_identifier()?;
+        self.expect_keyword_is(Keyword::SET)?;
+
+        let properties = match self.parse_options_with_keywords(&[Keyword::DCPROPERTIES])? {
+            properties if !properties.is_empty() => Some(properties),
+            _ => None,
+        };
+
+        let url = if self.parse_keyword(Keyword::URL) {
+            Some(self.parse_literal_string()?)
+        } else {
+            None
+        };
+
+        let owner = if self.parse_keywords(&[Keyword::OWNER, Keyword::USER]) {
+            let owner = self.parse_identifier()?;
+            Some(AlterConnectorOwner::User(owner))
+        } else if self.parse_keywords(&[Keyword::OWNER, Keyword::ROLE]) {
+            let owner = self.parse_identifier()?;
+            Some(AlterConnectorOwner::Role(owner))
+        } else {
+            None
+        };
+
+        Ok(Statement::AlterConnector {
+            name,
+            properties,
+            url,
+            owner,
+        })
+    }
+
     fn parse_mssql_alter_role(&mut self) -> Result<Statement, ParserError> {
         let role_name = self.parse_identifier()?;
 

src/test_utils.rs

@@ -33,7 +33,7 @@ use core::fmt::Debug;
 
 use crate::dialect::*;
 use crate::parser::{Parser, ParserError};
-use crate::tokenizer::Tokenizer;
+use crate::tokenizer::{Token, Tokenizer};
 use crate::{ast::*, parser::ParserOptions};
 
 #[cfg(test)]
@@ -151,6 +151,8 @@ impl TestedDialects {
     ///
     /// 2. re-serializing the result of parsing `sql` produces the same
     ///    `canonical` sql string
+    ///
+    ///  For multiple statements, use [`statements_parse_to`].
     pub fn one_statement_parses_to(&self, sql: &str, canonical: &str) -> Statement {
         let mut statements = self.parse_sql_statements(sql).expect(sql);
         assert_eq!(statements.len(), 1);
@@ -166,6 +168,24 @@ impl TestedDialects {
         only_statement
     }
 
+    /// The same as [`one_statement_parses_to`] but it works for a multiple statements
+    pub fn statements_parse_to(&self, sql: &str, canonical: &str) -> Vec<Statement> {
+        let statements = self.parse_sql_statements(sql).expect(sql);
+        if !canonical.is_empty() && sql != canonical {
+            assert_eq!(self.parse_sql_statements(canonical).unwrap(), statements);
+        } else {
+            assert_eq!(
+                sql,
+                statements
+                    .iter()
+                    .map(|s| s.to_string())
+                    .collect::<Vec<_>>()
+                    .join("; ")
+            );
+        }
+        statements
+    }
+
     /// Ensures that `sql` parses as an [`Expr`], and that
     /// re-serializing the parse result produces canonical
     pub fn expr_parses_to(&self, sql: &str, canonical: &str) -> Expr {
@@ -237,6 +257,22 @@ impl TestedDialects {
     pub fn verified_expr(&self, sql: &str) -> Expr {
         self.expr_parses_to(sql, sql)
     }
+
+    /// Check that the tokenizer returns the expected tokens for the given SQL.
+    pub fn tokenizes_to(&self, sql: &str, expected: Vec<Token>) {
+        if self.dialects.is_empty() {
+            panic!("No dialects to test");
+        }
+
+        self.dialects.iter().for_each(|dialect| {
+            let mut tokenizer = Tokenizer::new(&**dialect, sql);
+            if let Some(options) = &self.options {
+                tokenizer = tokenizer.with_unescape(options.unescape);
+            }
+            let tokens = tokenizer.tokenize().unwrap();
+            assert_eq!(expected, tokens, "Tokenized differently for {dialect:?}");
+        });
+    }
 }
 
 /// Returns all available dialects.
@@ -309,10 +345,12 @@ pub fn alter_table_op_with_name(stmt: Statement, expected_name: &str) -> AlterTa
             operations,
             on_cluster: _,
             location: _,
+            iceberg,
         } => {
             assert_eq!(name.to_string(), expected_name);
             assert!(!if_exists);
             assert!(!is_only);
+            assert!(!iceberg);
             only(operations)
         }
         _ => panic!("Expected ALTER TABLE statement"),
@@ -328,6 +366,11 @@ pub fn number(n: &str) -> Value {
     Value::Number(n.parse().unwrap(), false)
 }
 
+/// Creates a [Value::SingleQuotedString]
+pub fn single_quoted_string(s: impl Into<String>) -> Value {
+    Value::SingleQuotedString(s.into())
+}
+
 pub fn table_alias(name: impl Into<String>) -> Option<TableAlias> {
     Some(TableAlias {
         name: Ident::new(name),
@@ -337,7 +380,7 @@ pub fn table_alias(name: impl Into<String>) -> Option<TableAlias> {
 
 pub fn table(name: impl Into<String>) -> TableFactor {
     TableFactor::Table {
-        name: ObjectName(vec![Ident::new(name.into())]),
+        name: ObjectName::from(vec![Ident::new(name.into())]),
         alias: None,
         args: None,
         with_hints: vec![],
@@ -346,6 +389,7 @@ pub fn table(name: impl Into<String>) -> TableFactor {
         with_ordinality: false,
         json_path: None,
         sample: None,
+        index_hints: vec![],
     }
 }
 
@@ -360,12 +404,13 @@ pub fn table_from_name(name: ObjectName) -> TableFactor {
         with_ordinality: false,
         json_path: None,
         sample: None,
+        index_hints: vec![],
     }
 }
 
 pub fn table_with_alias(name: impl Into<String>, alias: impl Into<String>) -> TableFactor {
     TableFactor::Table {
-        name: ObjectName(vec![Ident::new(name)]),
+        name: ObjectName::from(vec![Ident::new(name)]),
         alias: Some(TableAlias {
             name: Ident::new(alias),
             columns: vec![],
@@ -377,6 +422,7 @@ pub fn table_with_alias(name: impl Into<String>, alias: impl Into<String>) -> Ta
         with_ordinality: false,
         json_path: None,
         sample: None,
+        index_hints: vec![],
     }
 }
 
@@ -384,13 +430,13 @@ pub fn join(relation: TableFactor) -> Join {
     Join {
         relation,
         global: false,
-        join_operator: JoinOperator::Inner(JoinConstraint::Natural),
+        join_operator: JoinOperator::Join(JoinConstraint::Natural),
     }
 }
 
 pub fn call(function: &str, args: impl IntoIterator<Item = Expr>) -> Expr {
     Expr::Function(Function {
-        name: ObjectName(vec![Ident::new(function)]),
+        name: ObjectName::from(vec![Ident::new(function)]),
         uses_odbc_syntax: false,
         parameters: FunctionArguments::None,
         args: FunctionArguments::List(FunctionArgumentList {
@@ -407,3 +453,52 @@ pub fn call(function: &str, args: impl IntoIterator<Item = Expr>) -> Expr {
         within_group: vec![],
     })
 }
+
+/// Gets the first index column (mysql calls it a key part) of the first index found in a
+/// [`Statement::CreateIndex`], [`Statement::CreateTable`], or [`Statement::AlterTable`].
+pub fn index_column(stmt: Statement) -> Expr {
+    match stmt {
+        Statement::CreateIndex(CreateIndex { columns, .. }) => {
+            columns.first().unwrap().column.expr.clone()
+        }
+        Statement::CreateTable(CreateTable { constraints, .. }) => {
+            match constraints.first().unwrap() {
+                TableConstraint::Index { columns, .. } => {
+                    columns.first().unwrap().column.expr.clone()
+                }
+                TableConstraint::Unique { columns, .. } => {
+                    columns.first().unwrap().column.expr.clone()
+                }
+                TableConstraint::PrimaryKey { columns, .. } => {
+                    columns.first().unwrap().column.expr.clone()
+                }
+                TableConstraint::FulltextOrSpatial { columns, .. } => {
+                    columns.first().unwrap().column.expr.clone()
+                }
+                _ => panic!("Expected an index, unique, primary, full text, or spatial constraint (foreign key does not support general key part expressions)"),
+            }
+        }
+        Statement::AlterTable { operations, .. } => match operations.first().unwrap() {
+            AlterTableOperation::AddConstraint { constraint, .. } => {
+                match constraint {
+                    TableConstraint::Index { columns, .. } => {
+                        columns.first().unwrap().column.expr.clone()
+                    }
+                    TableConstraint::Unique { columns, .. } => {
+                        columns.first().unwrap().column.expr.clone()
+                    }
+                    TableConstraint::PrimaryKey { columns, .. } => {
+                        columns.first().unwrap().column.expr.clone()
+                    }
+                    TableConstraint::FulltextOrSpatial {
+                        columns,
+                        ..
+                    } => columns.first().unwrap().column.expr.clone(),
+                    _ => panic!("Expected an index, unique, primary, full text, or spatial constraint (foreign key does not support general key part expressions)"),
+                }
+            }
+            _ => panic!("Expected a constraint"),
+        },
+        _ => panic!("Expected CREATE INDEX, ALTER TABLE, or CREATE TABLE, got: {stmt:?}"),
+    }
+}

src/tokenizer.rs

@@ -170,8 +170,10 @@ pub enum Token {
     RBrace,
     /// Right Arrow `=>`
     RArrow,
-    /// Sharp `#` used for PostgreSQL Bitwise XOR operator
+    /// Sharp `#` used for PostgreSQL Bitwise XOR operator, also PostgreSQL/Redshift geometrical unary/binary operator (Number of points in path or polygon/Intersection)
     Sharp,
+    /// `##` PostgreSQL/Redshift geometrical binary operator (Point of closest proximity)
+    DoubleSharp,
     /// Tilde `~` used for PostgreSQL Bitwise NOT operator or case sensitive match regular expression operator
     Tilde,
     /// `~*` , a case insensitive match regular expression operator in PostgreSQL
@@ -198,7 +200,7 @@ pub enum Token {
     ExclamationMark,
     /// Double Exclamation Mark `!!` used for PostgreSQL prefix factorial operator
     DoubleExclamationMark,
-    /// AtSign `@` used for PostgreSQL abs operator
+    /// AtSign `@` used for PostgreSQL abs operator, also PostgreSQL/Redshift geometrical unary/binary operator (Center, Contained or on)
     AtSign,
     /// `^@`, a "starts with" string operator in PostgreSQL
     CaretAt,
@@ -214,6 +216,38 @@ pub enum Token {
     LongArrow,
     /// `#>`, extracts JSON sub-object at the specified path
     HashArrow,
+    /// `@-@` PostgreSQL/Redshift geometrical unary operator (Length or circumference)
+    AtDashAt,
+    /// `?-` PostgreSQL/Redshift geometrical unary/binary operator (Is horizontal?/Are horizontally aligned?)
+    QuestionMarkDash,
+    /// `&<` PostgreSQL/Redshift geometrical binary operator (Overlaps to left?)
+    AmpersandLeftAngleBracket,
+    /// `&>` PostgreSQL/Redshift geometrical binary operator (Overlaps to right?)`
+    AmpersandRightAngleBracket,
+    /// `&<|` PostgreSQL/Redshift geometrical binary operator (Does not extend above?)`
+    AmpersandLeftAngleBracketVerticalBar,
+    /// `|&>` PostgreSQL/Redshift geometrical binary operator (Does not extend below?)`
+    VerticalBarAmpersandRightAngleBracket,
+    /// `<->` PostgreSQL/Redshift geometrical binary operator (Distance between)
+    TwoWayArrow,
+    /// `<^` PostgreSQL/Redshift geometrical binary operator (Is below?)
+    LeftAngleBracketCaret,
+    /// `>^` PostgreSQL/Redshift geometrical binary operator (Is above?)
+    RightAngleBracketCaret,
+    /// `?#` PostgreSQL/Redshift geometrical binary operator (Intersects or overlaps)
+    QuestionMarkSharp,
+    /// `?-|` PostgreSQL/Redshift geometrical binary operator (Is perpendicular?)
+    QuestionMarkDashVerticalBar,
+    /// `?||` PostgreSQL/Redshift geometrical binary operator (Are parallel?)
+    QuestionMarkDoubleVerticalBar,
+    /// `~=` PostgreSQL/Redshift geometrical binary operator (Same as)
+    TildeEqual,
+    /// `<<| PostgreSQL/Redshift geometrical binary operator (Is strictly below?)
+    ShiftLeftVerticalBar,
+    /// `|>> PostgreSQL/Redshift geometrical binary operator (Is strictly above?)
+    VerticalBarShiftRight,
+    /// `|> BigQuery pipe operator
+    VerticalBarRightAngleBracket,
     /// `#>>`, extracts JSON sub-object at the specified path as text
     HashLongArrow,
     /// jsonb @> jsonb -> boolean: Test whether left json contains the right json
@@ -303,6 +337,7 @@ impl fmt::Display for Token {
             Token::RBrace => f.write_str("}"),
             Token::RArrow => f.write_str("=>"),
             Token::Sharp => f.write_str("#"),
+            Token::DoubleSharp => f.write_str("##"),
             Token::ExclamationMark => f.write_str("!"),
             Token::DoubleExclamationMark => f.write_str("!!"),
             Token::Tilde => f.write_str("~"),
@@ -320,6 +355,22 @@ impl fmt::Display for Token {
             Token::Overlap => f.write_str("&&"),
             Token::PGSquareRoot => f.write_str("|/"),
             Token::PGCubeRoot => f.write_str("||/"),
+            Token::AtDashAt => f.write_str("@-@"),
+            Token::QuestionMarkDash => f.write_str("?-"),
+            Token::AmpersandLeftAngleBracket => f.write_str("&<"),
+            Token::AmpersandRightAngleBracket => f.write_str("&>"),
+            Token::AmpersandLeftAngleBracketVerticalBar => f.write_str("&<|"),
+            Token::VerticalBarAmpersandRightAngleBracket => f.write_str("|&>"),
+            Token::VerticalBarRightAngleBracket => f.write_str("|>"),
+            Token::TwoWayArrow => f.write_str("<->"),
+            Token::LeftAngleBracketCaret => f.write_str("<^"),
+            Token::RightAngleBracketCaret => f.write_str(">^"),
+            Token::QuestionMarkSharp => f.write_str("?#"),
+            Token::QuestionMarkDashVerticalBar => f.write_str("?-|"),
+            Token::QuestionMarkDoubleVerticalBar => f.write_str("?||"),
+            Token::TildeEqual => f.write_str("~="),
+            Token::ShiftLeftVerticalBar => f.write_str("<<|"),
+            Token::VerticalBarShiftRight => f.write_str("|>>"),
             Token::Placeholder(ref s) => write!(f, "{s}"),
             Token::Arrow => write!(f, "->"),
             Token::LongArrow => write!(f, "->>"),
@@ -847,7 +898,7 @@ impl<'a> Tokenizer<'a> {
         };
 
         let mut location = state.location();
-        while let Some(token) = self.next_token(&mut state)? {
+        while let Some(token) = self.next_token(&mut state, buf.last().map(|t| &t.token))? {
             let span = location.span_to(state.location());
 
             buf.push(TokenWithSpan { token, span });
@@ -884,7 +935,11 @@ impl<'a> Tokenizer<'a> {
     }
 
     /// Get the next token or return None
-    fn next_token(&self, chars: &mut State) -> Result<Option<Token>, TokenizerError> {
+    fn next_token(
+        &self,
+        chars: &mut State,
+        prev_token: Option<&Token>,
+    ) -> Result<Option<Token>, TokenizerError> {
         match chars.peek() {
             Some(&ch) => match ch {
                 ' ' => self.consume_and_return(chars, Token::Whitespace(Whitespace::Space)),
@@ -971,7 +1026,10 @@ impl<'a> Tokenizer<'a> {
                     match chars.peek() {
                         Some('\'') => {
                             // N'...' - a <national character string literal>
-                            let s = self.tokenize_single_quoted_string(chars, '\'', true)?;
+                            let backslash_escape =
+                                self.dialect.supports_string_literal_backslash_escape();
+                            let s =
+                                self.tokenize_single_quoted_string(chars, '\'', backslash_escape)?;
                             Ok(Some(Token::NationalStringLiteral(s)))
                         }
                         _ => {
@@ -982,7 +1040,7 @@ impl<'a> Tokenizer<'a> {
                     }
                 }
                 // PostgreSQL accepts "escape" string constants, which are an extension to the SQL standard.
-                x @ 'e' | x @ 'E' => {
+                x @ 'e' | x @ 'E' if self.dialect.supports_string_escape_constant() => {
                     let starting_loc = chars.location();
                     chars.next(); // consume, to check the next char
                     match chars.peek() {
@@ -1133,12 +1191,40 @@ impl<'a> Tokenizer<'a> {
                 }
                 // numbers and period
                 '0'..='9' | '.' => {
-                    let mut s = peeking_take_while(chars, |ch| ch.is_ascii_digit());
+                    // special case where if ._ is encountered after a word then that word
+                    // is a table and the _ is the start of the col name.
+                    // if the prev token is not a word, then this is not a valid sql
+                    // word or number.
+                    if ch == '.' && chars.peekable.clone().nth(1) == Some('_') {
+                        if let Some(Token::Word(_)) = prev_token {
+                            chars.next();
+                            return Ok(Some(Token::Period));
+                        }
+
+                        return self.tokenizer_error(
+                            chars.location(),
+                            "Unexpected character '_'".to_string(),
+                        );
+                    }
+
+                    // Some dialects support underscore as number separator
+                    // There can only be one at a time and it must be followed by another digit
+                    let is_number_separator = |ch: char, next_char: Option<char>| {
+                        self.dialect.supports_numeric_literal_underscores()
+                            && ch == '_'
+                            && next_char.is_some_and(|next_ch| next_ch.is_ascii_hexdigit())
+                    };
+
+                    let mut s = peeking_next_take_while(chars, |ch, next_ch| {
+                        ch.is_ascii_digit() || is_number_separator(ch, next_ch)
+                    });
 
                     // match binary literal that starts with 0x
                     if s == "0" && chars.peek() == Some(&'x') {
                         chars.next();
-                        let s2 = peeking_take_while(chars, |ch| ch.is_ascii_hexdigit());
+                        let s2 = peeking_next_take_while(chars, |ch, next_ch| {
+                            ch.is_ascii_hexdigit() || is_number_separator(ch, next_ch)
+                        });
                         return Ok(Some(Token::HexStringLiteral(s2)));
                     }
 
@@ -1147,15 +1233,30 @@ impl<'a> Tokenizer<'a> {
                         s.push('.');
                         chars.next();
                     }
-                    s += &peeking_take_while(chars, |ch| ch.is_ascii_digit());
 
-                    // No number -> Token::Period
+                    // If the dialect supports identifiers that start with a numeric prefix
+                    // and we have now consumed a dot, check if the previous token was a Word.
+                    // If so, what follows is definitely not part of a decimal number and
+                    // we should yield the dot as a dedicated token so compound identifiers
+                    // starting with digits can be parsed correctly.
+                    if s == "." && self.dialect.supports_numeric_prefix() {
+                        if let Some(Token::Word(_)) = prev_token {
+                            return Ok(Some(Token::Period));
+                        }
+                    }
+
+                    // Consume fractional digits.
+                    s += &peeking_next_take_while(chars, |ch, next_ch| {
+                        ch.is_ascii_digit() || is_number_separator(ch, next_ch)
+                    });
+
+                    // No fraction -> Token::Period
                     if s == "." {
                         return Ok(Some(Token::Period));
                     }
 
-                    let mut exponent_part = String::new();
                     // Parse exponent as number
+                    let mut exponent_part = String::new();
                     if chars.peek() == Some(&'e') || chars.peek() == Some(&'E') {
                         let mut char_clone = chars.peekable.clone();
                         exponent_part.push(char_clone.next().unwrap());
@@ -1184,14 +1285,23 @@ impl<'a> Tokenizer<'a> {
                         }
                     }
 
-                    // mysql dialect supports identifiers that start with a numeric prefix,
-                    // as long as they aren't an exponent number.
-                    if self.dialect.supports_numeric_prefix() && exponent_part.is_empty() {
-                        let word =
-                            peeking_take_while(chars, |ch| self.dialect.is_identifier_part(ch));
+                    // If the dialect supports identifiers that start with a numeric prefix,
+                    // we need to check if the value is in fact an identifier and must thus
+                    // be tokenized as a word.
+                    if self.dialect.supports_numeric_prefix() {
+                        if exponent_part.is_empty() {
+                            // If it is not a number with an exponent, it may be
+                            // an identifier starting with digits.
+                            let word =
+                                peeking_take_while(chars, |ch| self.dialect.is_identifier_part(ch));
 
-                        if !word.is_empty() {
-                            s += word.as_str();
+                            if !word.is_empty() {
+                                s += word.as_str();
+                                return Ok(Some(Token::make_word(s.as_str(), None)));
+                            }
+                        } else if prev_token == Some(&Token::Period) {
+                            // If the previous token was a period, thus not belonging to a number,
+                            // the value we have is part of an identifier.
                             return Ok(Some(Token::make_word(s.as_str(), None)));
                         }
                     }
@@ -1211,14 +1321,26 @@ impl<'a> Tokenizer<'a> {
                 // operators
                 '-' => {
                     chars.next(); // consume the '-'
+
                     match chars.peek() {
                         Some('-') => {
-                            chars.next(); // consume the second '-', starting a single-line comment
-                            let comment = self.tokenize_single_line_comment(chars);
-                            Ok(Some(Token::Whitespace(Whitespace::SingleLineComment {
-                                prefix: "--".to_owned(),
-                                comment,
-                            })))
+                            let mut is_comment = true;
+                            if self.dialect.requires_single_line_comment_whitespace() {
+                                is_comment = Some(' ') == chars.peekable.clone().nth(1);
+                            }
+
+                            if is_comment {
+                                chars.next(); // consume second '-'
+                                let comment = self.tokenize_single_line_comment(chars);
+                                return Ok(Some(Token::Whitespace(
+                                    Whitespace::SingleLineComment {
+                                        prefix: "--".to_owned(),
+                                        comment,
+                                    },
+                                )));
+                            }
+
+                            self.start_binop(chars, "-", Token::Minus)
                         }
                         Some('>') => {
                             chars.next();
@@ -1278,6 +1400,31 @@ impl<'a> Tokenizer<'a> {
                                 _ => self.start_binop(chars, "||", Token::StringConcat),
                             }
                         }
+                        Some('&') if self.dialect.supports_geometric_types() => {
+                            chars.next(); // consume
+                            match chars.peek() {
+                                Some('>') => self.consume_for_binop(
+                                    chars,
+                                    "|&>",
+                                    Token::VerticalBarAmpersandRightAngleBracket,
+                                ),
+                                _ => self.start_binop_opt(chars, "|&", None),
+                            }
+                        }
+                        Some('>') if self.dialect.supports_geometric_types() => {
+                            chars.next(); // consume
+                            match chars.peek() {
+                                Some('>') => self.consume_for_binop(
+                                    chars,
+                                    "|>>",
+                                    Token::VerticalBarShiftRight,
+                                ),
+                                _ => self.start_binop_opt(chars, "|>", None),
+                            }
+                        }
+                        Some('>') if self.dialect.supports_pipe_operator() => {
+                            self.consume_for_binop(chars, "|>", Token::VerticalBarRightAngleBracket)
+                        }
                         // Bitshift '|' operator
                         _ => self.start_binop(chars, "|", Token::Pipe),
                     }
@@ -1326,8 +1473,34 @@ impl<'a> Tokenizer<'a> {
                                 _ => self.start_binop(chars, "<=", Token::LtEq),
                             }
                         }
+                        Some('|') if self.dialect.supports_geometric_types() => {
+                            self.consume_for_binop(chars, "<<|", Token::ShiftLeftVerticalBar)
+                        }
                         Some('>') => self.consume_for_binop(chars, "<>", Token::Neq),
+                        Some('<') if self.dialect.supports_geometric_types() => {
+                            chars.next(); // consume
+                            match chars.peek() {
+                                Some('|') => self.consume_for_binop(
+                                    chars,
+                                    "<<|",
+                                    Token::ShiftLeftVerticalBar,
+                                ),
+                                _ => self.start_binop(chars, "<<", Token::ShiftLeft),
+                            }
+                        }
                         Some('<') => self.consume_for_binop(chars, "<<", Token::ShiftLeft),
+                        Some('-') if self.dialect.supports_geometric_types() => {
+                            chars.next(); // consume
+                            match chars.peek() {
+                                Some('>') => {
+                                    self.consume_for_binop(chars, "<->", Token::TwoWayArrow)
+                                }
+                                _ => self.start_binop_opt(chars, "<-", None),
+                            }
+                        }
+                        Some('^') if self.dialect.supports_geometric_types() => {
+                            self.consume_for_binop(chars, "<^", Token::LeftAngleBracketCaret)
+                        }
                         Some('@') => self.consume_for_binop(chars, "<@", Token::ArrowAt),
                         _ => self.start_binop(chars, "<", Token::Lt),
                     }
@@ -1337,6 +1510,9 @@ impl<'a> Tokenizer<'a> {
                     match chars.peek() {
                         Some('=') => self.consume_for_binop(chars, ">=", Token::GtEq),
                         Some('>') => self.consume_for_binop(chars, ">>", Token::ShiftRight),
+                        Some('^') if self.dialect.supports_geometric_types() => {
+                            self.consume_for_binop(chars, ">^", Token::RightAngleBracketCaret)
+                        }
                         _ => self.start_binop(chars, ">", Token::Gt),
                     }
                 }
@@ -1355,6 +1531,22 @@ impl<'a> Tokenizer<'a> {
                 '&' => {
                     chars.next(); // consume the '&'
                     match chars.peek() {
+                        Some('>') if self.dialect.supports_geometric_types() => {
+                            chars.next();
+                            self.consume_and_return(chars, Token::AmpersandRightAngleBracket)
+                        }
+                        Some('<') if self.dialect.supports_geometric_types() => {
+                            chars.next(); // consume
+                            match chars.peek() {
+                                Some('|') => self.consume_and_return(
+                                    chars,
+                                    Token::AmpersandLeftAngleBracketVerticalBar,
+                                ),
+                                _ => {
+                                    self.start_binop(chars, "&<", Token::AmpersandLeftAngleBracket)
+                                }
+                            }
+                        }
                         Some('&') => {
                             chars.next(); // consume the second '&'
                             self.start_binop(chars, "&&", Token::Overlap)
@@ -1385,6 +1577,9 @@ impl<'a> Tokenizer<'a> {
                     chars.next(); // consume
                     match chars.peek() {
                         Some('*') => self.consume_for_binop(chars, "~*", Token::TildeAsterisk),
+                        Some('=') if self.dialect.supports_geometric_types() => {
+                            self.consume_for_binop(chars, "~=", Token::TildeEqual)
+                        }
                         Some('~') => {
                             chars.next();
                             match chars.peek() {
@@ -1411,6 +1606,9 @@ impl<'a> Tokenizer<'a> {
                             }
                         }
                         Some(' ') => Ok(Some(Token::Sharp)),
+                        Some('#') if self.dialect.supports_geometric_types() => {
+                            self.consume_for_binop(chars, "##", Token::DoubleSharp)
+                        }
                         Some(sch) if self.dialect.is_identifier_start('#') => {
                             self.tokenize_identifier_or_keyword([ch, *sch], chars)
                         }
@@ -1420,6 +1618,16 @@ impl<'a> Tokenizer<'a> {
                 '@' => {
                     chars.next();
                     match chars.peek() {
+                        Some('@') if self.dialect.supports_geometric_types() => {
+                            self.consume_and_return(chars, Token::AtAt)
+                        }
+                        Some('-') if self.dialect.supports_geometric_types() => {
+                            chars.next();
+                            match chars.peek() {
+                                Some('@') => self.consume_and_return(chars, Token::AtDashAt),
+                                _ => self.start_binop_opt(chars, "@-", None),
+                            }
+                        }
                         Some('>') => self.consume_and_return(chars, Token::AtArrow),
                         Some('?') => self.consume_and_return(chars, Token::AtQuestion),
                         Some('@') => {
@@ -1452,11 +1660,30 @@ impl<'a> Tokenizer<'a> {
                     }
                 }
                 // Postgres uses ? for jsonb operators, not prepared statements
-                '?' if dialect_of!(self is PostgreSqlDialect) => {
-                    chars.next();
+                '?' if self.dialect.supports_geometric_types() => {
+                    chars.next(); // consume
                     match chars.peek() {
-                        Some('|') => self.consume_and_return(chars, Token::QuestionPipe),
+                        Some('|') => {
+                            chars.next();
+                            match chars.peek() {
+                                Some('|') => self.consume_and_return(
+                                    chars,
+                                    Token::QuestionMarkDoubleVerticalBar,
+                                ),
+                                _ => Ok(Some(Token::QuestionPipe)),
+                            }
+                        }
+
                         Some('&') => self.consume_and_return(chars, Token::QuestionAnd),
+                        Some('-') => {
+                            chars.next(); // consume
+                            match chars.peek() {
+                                Some('|') => self
+                                    .consume_and_return(chars, Token::QuestionMarkDashVerticalBar),
+                                _ => Ok(Some(Token::QuestionMarkDash)),
+                            }
+                        }
+                        Some('#') => self.consume_and_return(chars, Token::QuestionMarkSharp),
                         _ => self.consume_and_return(chars, Token::Question),
                     }
                 }
@@ -1490,7 +1717,7 @@ impl<'a> Tokenizer<'a> {
         default: Token,
     ) -> Result<Option<Token>, TokenizerError> {
         chars.next(); // consume the first char
-        self.start_binop(chars, prefix, default)
+        self.start_binop_opt(chars, prefix, Some(default))
     }
 
     /// parse a custom binary operator
@@ -1499,6 +1726,16 @@ impl<'a> Tokenizer<'a> {
         chars: &mut State,
         prefix: &str,
         default: Token,
+    ) -> Result<Option<Token>, TokenizerError> {
+        self.start_binop_opt(chars, prefix, Some(default))
+    }
+
+    /// parse a custom binary operator
+    fn start_binop_opt(
+        &self,
+        chars: &mut State,
+        prefix: &str,
+        default: Option<Token>,
     ) -> Result<Option<Token>, TokenizerError> {
         let mut custom = None;
         while let Some(&ch) = chars.peek() {
@@ -1509,10 +1746,14 @@ impl<'a> Tokenizer<'a> {
             custom.get_or_insert_with(|| prefix.to_string()).push(ch);
             chars.next();
         }
-
-        Ok(Some(
-            custom.map(Token::CustomBinaryOperator).unwrap_or(default),
-        ))
+        match (custom, default) {
+            (Some(custom), _) => Ok(Token::CustomBinaryOperator(custom).into()),
+            (None, Some(tok)) => Ok(Some(tok)),
+            (None, None) => self.tokenizer_error(
+                chars.location(),
+                format!("Expected a valid binary operator after '{prefix}'"),
+            ),
+        }
     }
 
     /// Tokenize dollar preceded value (i.e: a string/placeholder)
@@ -1568,7 +1809,7 @@ impl<'a> Tokenizer<'a> {
                 chars.next();
 
                 let mut temp = String::new();
-                let end_delimiter = format!("${}$", value);
+                let end_delimiter = format!("${value}$");
 
                 loop {
                     match chars.next() {
@@ -1817,8 +2058,13 @@ impl<'a> Tokenizer<'a> {
                     num_consecutive_quotes = 0;
 
                     if let Some(next) = chars.peek() {
-                        if !self.unescape {
-                            // In no-escape mode, the given query has to be saved completely including backslashes.
+                        if !self.unescape
+                            || (self.dialect.ignores_wildcard_escapes()
+                                && (*next == '%' || *next == '_'))
+                        {
+                            // In no-escape mode, the given query has to be saved completely
+                            // including backslashes. Similarly, with ignore_like_wildcard_escapes,
+                            // the backslash is not stripped.
                             s.push(ch);
                             s.push(*next);
                             chars.next(); // consume next
@@ -1943,6 +2189,24 @@ fn peeking_take_while(chars: &mut State, mut predicate: impl FnMut(char) -> bool
     s
 }
 
+/// Same as peeking_take_while, but also passes the next character to the predicate.
+fn peeking_next_take_while(
+    chars: &mut State,
+    mut predicate: impl FnMut(char, Option<char>) -> bool,
+) -> String {
+    let mut s = String::new();
+    while let Some(&ch) = chars.peek() {
+        let next_char = chars.peekable.clone().nth(1);
+        if predicate(ch, next_char) {
+            chars.next(); // consume
+            s.push(ch);
+        } else {
+            break;
+        }
+    }
+    s
+}
+
 fn unescape_single_quoted_string(chars: &mut State<'_>) -> Option<String> {
     Unescape::new(chars).unescape()
 }
@@ -2138,13 +2402,13 @@ fn take_char_from_hex_digits(
             location: chars.location(),
         })?;
         let digit = next_char.to_digit(16).ok_or_else(|| TokenizerError {
-            message: format!("Invalid hex digit in escaped unicode string: {}", next_char),
+            message: format!("Invalid hex digit in escaped unicode string: {next_char}"),
             location: chars.location(),
         })?;
         result = result * 16 + digit;
     }
     char::from_u32(result).ok_or_else(|| TokenizerError {
-        message: format!("Invalid unicode character: {:x}", result),
+        message: format!("Invalid unicode character: {result:x}"),
         location: chars.location(),
     })
 }
@@ -2155,6 +2419,7 @@ mod tests {
     use crate::dialect::{
         BigQueryDialect, ClickHouseDialect, HiveDialect, MsSqlDialect, MySqlDialect, SQLiteDialect,
     };
+    use crate::test_utils::all_dialects_where;
     use core::fmt::Debug;
 
     #[test]
@@ -2223,6 +2488,41 @@ mod tests {
         compare(expected, tokens);
     }
 
+    #[test]
+    fn tokenize_numeric_literal_underscore() {
+        let dialect = GenericDialect {};
+        let sql = String::from("SELECT 10_000");
+        let mut tokenizer = Tokenizer::new(&dialect, &sql);
+        let tokens = tokenizer.tokenize().unwrap();
+        let expected = vec![
+            Token::make_keyword("SELECT"),
+            Token::Whitespace(Whitespace::Space),
+            Token::Number("10".to_string(), false),
+            Token::make_word("_000", None),
+        ];
+        compare(expected, tokens);
+
+        all_dialects_where(|dialect| dialect.supports_numeric_literal_underscores()).tokenizes_to(
+            "SELECT 10_000, _10_000, 10_00_, 10___0",
+            vec![
+                Token::make_keyword("SELECT"),
+                Token::Whitespace(Whitespace::Space),
+                Token::Number("10_000".to_string(), false),
+                Token::Comma,
+                Token::Whitespace(Whitespace::Space),
+                Token::make_word("_10_000", None), // leading underscore tokenizes as a word (parsed as column identifier)
+                Token::Comma,
+                Token::Whitespace(Whitespace::Space),
+                Token::Number("10_00".to_string(), false),
+                Token::make_word("_", None), // trailing underscores tokenizes as a word (syntax error in some dialects)
+                Token::Comma,
+                Token::Whitespace(Whitespace::Space),
+                Token::Number("10".to_string(), false),
+                Token::make_word("___0", None), // multiple underscores tokenizes as a word (syntax error in some dialects)
+            ],
+        );
+    }
+
     #[test]
     fn tokenize_select_exponent() {
         let sql = String::from("SELECT 1e10, 1e-10, 1e+10, 1ea, 1e-10a, 1e-10-10");
@@ -3204,7 +3504,7 @@ mod tests {
     }
 
     fn check_unescape(s: &str, expected: Option<&str>) {
-        let s = format!("'{}'", s);
+        let s = format!("'{s}'");
         let mut state = State {
             peekable: s.chars().peekable(),
             line: 0,
@@ -3337,6 +3637,9 @@ mod tests {
             (r#"'\\a\\b\'c'"#, r#"\\a\\b\'c"#, r#"\a\b'c"#),
             (r#"'\'abcd'"#, r#"\'abcd"#, r#"'abcd"#),
             (r#"'''a''b'"#, r#"''a''b"#, r#"'a'b"#),
+            (r#"'\q'"#, r#"\q"#, r#"q"#),
+            (r#"'\%\_'"#, r#"\%\_"#, r#"%_"#),
+            (r#"'\\%\\_'"#, r#"\\%\\_"#, r#"\%\_"#),
         ] {
             let tokens = Tokenizer::new(&dialect, sql)
                 .with_unescape(false)
@@ -3370,6 +3673,16 @@ mod tests {
 
             compare(expected, tokens);
         }
+
+        // MySQL special case for LIKE escapes
+        for (sql, expected) in [(r#"'\%'"#, r#"\%"#), (r#"'\_'"#, r#"\_"#)] {
+            let dialect = MySqlDialect {};
+            let tokens = Tokenizer::new(&dialect, sql).tokenize().unwrap();
+
+            let expected = vec![Token::SingleQuotedString(expected.to_string())];
+
+            compare(expected, tokens);
+        }
     }
 
     #[test]
@@ -3543,4 +3856,218 @@ mod tests {
         ];
         compare(expected, tokens);
     }
+
+    #[test]
+    fn test_national_strings_backslash_escape_not_supported() {
+        all_dialects_where(|dialect| !dialect.supports_string_literal_backslash_escape())
+            .tokenizes_to(
+                "select n'''''\\'",
+                vec![
+                    Token::make_keyword("select"),
+                    Token::Whitespace(Whitespace::Space),
+                    Token::NationalStringLiteral("''\\".to_string()),
+                ],
+            );
+    }
+
+    #[test]
+    fn test_national_strings_backslash_escape_supported() {
+        all_dialects_where(|dialect| dialect.supports_string_literal_backslash_escape())
+            .tokenizes_to(
+                "select n'''''\\''",
+                vec![
+                    Token::make_keyword("select"),
+                    Token::Whitespace(Whitespace::Space),
+                    Token::NationalStringLiteral("'''".to_string()),
+                ],
+            );
+    }
+
+    #[test]
+    fn test_string_escape_constant_not_supported() {
+        all_dialects_where(|dialect| !dialect.supports_string_escape_constant()).tokenizes_to(
+            "select e'...'",
+            vec![
+                Token::make_keyword("select"),
+                Token::Whitespace(Whitespace::Space),
+                Token::make_word("e", None),
+                Token::SingleQuotedString("...".to_string()),
+            ],
+        );
+
+        all_dialects_where(|dialect| !dialect.supports_string_escape_constant()).tokenizes_to(
+            "select E'...'",
+            vec![
+                Token::make_keyword("select"),
+                Token::Whitespace(Whitespace::Space),
+                Token::make_word("E", None),
+                Token::SingleQuotedString("...".to_string()),
+            ],
+        );
+    }
+
+    #[test]
+    fn test_string_escape_constant_supported() {
+        all_dialects_where(|dialect| dialect.supports_string_escape_constant()).tokenizes_to(
+            "select e'\\''",
+            vec![
+                Token::make_keyword("select"),
+                Token::Whitespace(Whitespace::Space),
+                Token::EscapedStringLiteral("'".to_string()),
+            ],
+        );
+
+        all_dialects_where(|dialect| dialect.supports_string_escape_constant()).tokenizes_to(
+            "select E'\\''",
+            vec![
+                Token::make_keyword("select"),
+                Token::Whitespace(Whitespace::Space),
+                Token::EscapedStringLiteral("'".to_string()),
+            ],
+        );
+    }
+
+    #[test]
+    fn test_whitespace_required_after_single_line_comment() {
+        all_dialects_where(|dialect| dialect.requires_single_line_comment_whitespace())
+            .tokenizes_to(
+                "SELECT --'abc'",
+                vec![
+                    Token::make_keyword("SELECT"),
+                    Token::Whitespace(Whitespace::Space),
+                    Token::Minus,
+                    Token::Minus,
+                    Token::SingleQuotedString("abc".to_string()),
+                ],
+            );
+
+        all_dialects_where(|dialect| dialect.requires_single_line_comment_whitespace())
+            .tokenizes_to(
+                "SELECT -- 'abc'",
+                vec![
+                    Token::make_keyword("SELECT"),
+                    Token::Whitespace(Whitespace::Space),
+                    Token::Whitespace(Whitespace::SingleLineComment {
+                        prefix: "--".to_string(),
+                        comment: " 'abc'".to_string(),
+                    }),
+                ],
+            );
+
+        all_dialects_where(|dialect| dialect.requires_single_line_comment_whitespace())
+            .tokenizes_to(
+                "SELECT --",
+                vec![
+                    Token::make_keyword("SELECT"),
+                    Token::Whitespace(Whitespace::Space),
+                    Token::Minus,
+                    Token::Minus,
+                ],
+            );
+    }
+
+    #[test]
+    fn test_whitespace_not_required_after_single_line_comment() {
+        all_dialects_where(|dialect| !dialect.requires_single_line_comment_whitespace())
+            .tokenizes_to(
+                "SELECT --'abc'",
+                vec![
+                    Token::make_keyword("SELECT"),
+                    Token::Whitespace(Whitespace::Space),
+                    Token::Whitespace(Whitespace::SingleLineComment {
+                        prefix: "--".to_string(),
+                        comment: "'abc'".to_string(),
+                    }),
+                ],
+            );
+
+        all_dialects_where(|dialect| !dialect.requires_single_line_comment_whitespace())
+            .tokenizes_to(
+                "SELECT -- 'abc'",
+                vec![
+                    Token::make_keyword("SELECT"),
+                    Token::Whitespace(Whitespace::Space),
+                    Token::Whitespace(Whitespace::SingleLineComment {
+                        prefix: "--".to_string(),
+                        comment: " 'abc'".to_string(),
+                    }),
+                ],
+            );
+
+        all_dialects_where(|dialect| !dialect.requires_single_line_comment_whitespace())
+            .tokenizes_to(
+                "SELECT --",
+                vec![
+                    Token::make_keyword("SELECT"),
+                    Token::Whitespace(Whitespace::Space),
+                    Token::Whitespace(Whitespace::SingleLineComment {
+                        prefix: "--".to_string(),
+                        comment: "".to_string(),
+                    }),
+                ],
+            );
+    }
+
+    #[test]
+    fn test_tokenize_identifiers_numeric_prefix() {
+        all_dialects_where(|dialect| dialect.supports_numeric_prefix())
+            .tokenizes_to("123abc", vec![Token::make_word("123abc", None)]);
+
+        all_dialects_where(|dialect| dialect.supports_numeric_prefix())
+            .tokenizes_to("12e34", vec![Token::Number("12e34".to_string(), false)]);
+
+        all_dialects_where(|dialect| dialect.supports_numeric_prefix()).tokenizes_to(
+            "t.12e34",
+            vec![
+                Token::make_word("t", None),
+                Token::Period,
+                Token::make_word("12e34", None),
+            ],
+        );
+
+        all_dialects_where(|dialect| dialect.supports_numeric_prefix()).tokenizes_to(
+            "t.1two3",
+            vec![
+                Token::make_word("t", None),
+                Token::Period,
+                Token::make_word("1two3", None),
+            ],
+        );
+    }
+
+    #[test]
+    fn tokenize_period_underscore() {
+        let sql = String::from("SELECT table._col");
+        // a dialect that supports underscores in numeric literals
+        let dialect = PostgreSqlDialect {};
+        let tokens = Tokenizer::new(&dialect, &sql).tokenize().unwrap();
+
+        let expected = vec![
+            Token::make_keyword("SELECT"),
+            Token::Whitespace(Whitespace::Space),
+            Token::Word(Word {
+                value: "table".to_string(),
+                quote_style: None,
+                keyword: Keyword::TABLE,
+            }),
+            Token::Period,
+            Token::Word(Word {
+                value: "_col".to_string(),
+                quote_style: None,
+                keyword: Keyword::NoKeyword,
+            }),
+        ];
+
+        compare(expected, tokens);
+
+        let sql = String::from("SELECT ._123");
+        if let Ok(tokens) = Tokenizer::new(&dialect, &sql).tokenize() {
+            panic!("Tokenizer should have failed on {sql}, but it succeeded with {tokens:?}");
+        }
+
+        let sql = String::from("SELECT ._abc");
+        if let Ok(tokens) = Tokenizer::new(&dialect, &sql).tokenize() {
+            panic!("Tokenizer should have failed on {sql}, but it succeeded with {tokens:?}");
+        }
+    }
 }

tests/pretty_print.rs

@@ -0,0 +1,414 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use sqlparser::dialect::GenericDialect;
+use sqlparser::parser::Parser;
+
+fn prettify(sql: &str) -> String {
+    let ast = Parser::parse_sql(&GenericDialect {}, sql).unwrap();
+    format!("{:#}", ast[0])
+}
+
+#[test]
+fn test_pretty_print_select() {
+    assert_eq!(
+        prettify("SELECT a, b, c FROM my_table WHERE x = 1 AND y = 2"),
+        r#"
+SELECT
+  a,
+  b,
+  c
+FROM
+  my_table
+WHERE
+  x = 1 AND y = 2
+"#
+        .trim()
+    );
+}
+
+#[test]
+fn test_pretty_print_join() {
+    assert_eq!(
+        prettify("SELECT a FROM table1 JOIN table2 ON table1.id = table2.id"),
+        r#"
+SELECT
+  a
+FROM
+  table1
+  JOIN table2 ON table1.id = table2.id
+"#
+        .trim()
+    );
+}
+
+#[test]
+fn test_pretty_print_subquery() {
+    assert_eq!(
+        prettify("SELECT * FROM (SELECT a, b FROM my_table) AS subquery"),
+        r#"
+SELECT
+  *
+FROM
+  (
+    SELECT
+      a,
+      b
+    FROM
+      my_table
+  ) AS subquery
+"#
+        .trim()
+    );
+}
+
+#[test]
+fn test_pretty_print_union() {
+    assert_eq!(
+        prettify("SELECT a FROM table1 UNION SELECT b FROM table2"),
+        r#"
+SELECT
+  a
+FROM
+  table1
+UNION
+SELECT
+  b
+FROM
+  table2
+"#
+        .trim()
+    );
+}
+
+#[test]
+fn test_pretty_print_group_by() {
+    assert_eq!(
+        prettify("SELECT a, COUNT(*) FROM my_table GROUP BY a HAVING COUNT(*) > 1"),
+        r#"
+SELECT
+  a,
+  COUNT(*)
+FROM
+  my_table
+GROUP BY
+  a
+HAVING
+  COUNT(*) > 1
+"#
+        .trim()
+    );
+}
+
+#[test]
+fn test_pretty_print_cte() {
+    assert_eq!(
+        prettify("WITH cte AS (SELECT a, b FROM my_table) SELECT * FROM cte"),
+        r#"
+WITH cte AS (
+  SELECT
+    a,
+    b
+  FROM
+    my_table
+)
+SELECT
+  *
+FROM
+  cte
+"#
+        .trim()
+    );
+}
+
+#[test]
+fn test_pretty_print_case_when() {
+    assert_eq!(
+        prettify("SELECT CASE WHEN x > 0 THEN 'positive' WHEN x < 0 THEN 'negative' ELSE 'zero' END FROM my_table"),
+        r#"
+SELECT
+  CASE
+    WHEN x > 0 THEN
+      'positive'
+    WHEN x < 0 THEN
+      'negative'
+    ELSE
+      'zero'
+  END
+FROM
+  my_table
+"#.trim()
+    );
+}
+
+#[test]
+fn test_pretty_print_window_function() {
+    assert_eq!(
+        prettify("SELECT id, value, ROW_NUMBER() OVER (PARTITION BY category ORDER BY value DESC) as rank FROM my_table"),
+        r#"
+SELECT
+  id,
+  value,
+  ROW_NUMBER() OVER (
+    PARTITION BY category
+    ORDER BY value DESC
+  ) AS rank
+FROM
+  my_table
+"#.trim()
+    );
+}
+
+#[test]
+fn test_pretty_print_multiline_string() {
+    assert_eq!(
+        prettify("SELECT 'multiline\nstring' AS str"),
+        r#"
+SELECT
+  'multiline
+string' AS str
+"#
+        .trim(),
+        "A  literal string with a newline should be kept as is. The contents of the string should not be indented."
+    );
+}
+
+#[test]
+fn test_pretty_print_insert_values() {
+    assert_eq!(
+        prettify("INSERT INTO my_table (a, b, c) VALUES (1, 2, 3), (4, 5, 6)"),
+        r#"
+INSERT INTO my_table (a, b, c)
+VALUES
+  (1, 2, 3),
+  (4, 5, 6)
+"#
+        .trim()
+    );
+}
+
+#[test]
+fn test_pretty_print_insert_select() {
+    assert_eq!(
+        prettify("INSERT INTO my_table (a, b) SELECT x, y FROM source_table RETURNING a AS id"),
+        r#"
+INSERT INTO my_table (a, b)
+SELECT
+  x,
+  y
+FROM
+  source_table
+RETURNING
+  a AS id
+"#
+        .trim()
+    );
+}
+
+#[test]
+fn test_pretty_print_update() {
+    assert_eq!(
+        prettify("UPDATE my_table SET a = 1, b = 2 WHERE x > 0 RETURNING id, name"),
+        r#"
+UPDATE my_table
+SET
+  a = 1,
+  b = 2
+WHERE
+  x > 0
+RETURNING
+  id,
+  name
+"#
+        .trim()
+    );
+}
+
+#[test]
+fn test_pretty_print_delete() {
+    assert_eq!(
+        prettify("DELETE FROM my_table WHERE x > 0 RETURNING id, name"),
+        r#"
+DELETE FROM
+  my_table
+WHERE
+  x > 0
+RETURNING
+  id,
+  name
+"#
+        .trim()
+    );
+
+    assert_eq!(
+        prettify("DELETE table1, table2"),
+        r#"
+DELETE
+  table1,
+  table2
+"#
+        .trim()
+    );
+}
+
+#[test]
+fn test_pretty_print_create_table() {
+    assert_eq!(
+        prettify("CREATE TABLE my_table (id INT PRIMARY KEY, name VARCHAR(255) NOT NULL, CONSTRAINT fk_other FOREIGN KEY (id) REFERENCES other_table(id))"),
+        r#"
+CREATE TABLE my_table (
+  id INT PRIMARY KEY,
+  name VARCHAR(255) NOT NULL,
+  CONSTRAINT fk_other FOREIGN KEY (id) REFERENCES other_table(id)
+)
+"#
+        .trim()
+    );
+}
+
+#[test]
+fn test_pretty_print_create_view() {
+    assert_eq!(
+        prettify("CREATE VIEW my_view AS SELECT a, b FROM my_table WHERE x > 0"),
+        r#"
+CREATE VIEW my_view AS
+SELECT
+  a,
+  b
+FROM
+  my_table
+WHERE
+  x > 0
+"#
+        .trim()
+    );
+}
+
+#[test]
+#[ignore = "https://github.com/apache/datafusion-sqlparser-rs/issues/1850"]
+fn test_pretty_print_create_function() {
+    assert_eq!(
+        prettify("CREATE FUNCTION my_func() RETURNS INT BEGIN SELECT COUNT(*) INTO @count FROM my_table; RETURN @count; END"),
+        r#"
+CREATE FUNCTION my_func() RETURNS INT
+BEGIN
+  SELECT COUNT(*) INTO @count FROM my_table;
+  RETURN @count;
+END
+"#
+        .trim()
+    );
+}
+
+#[test]
+#[ignore = "https://github.com/apache/datafusion-sqlparser-rs/issues/1850"]
+fn test_pretty_print_json_table() {
+    assert_eq!(
+        prettify("SELECT * FROM JSON_TABLE(@json, '$[*]' COLUMNS (id INT PATH '$.id', name VARCHAR(255) PATH '$.name')) AS jt"),
+        r#"
+SELECT
+  *
+FROM
+  JSON_TABLE(
+    @json,
+    '$[*]' COLUMNS (
+      id INT PATH '$.id',
+      name VARCHAR(255) PATH '$.name'
+    )
+  ) AS jt
+"#
+        .trim()
+    );
+}
+
+#[test]
+#[ignore = "https://github.com/apache/datafusion-sqlparser-rs/issues/1850"]
+fn test_pretty_print_transaction_blocks() {
+    assert_eq!(
+        prettify("BEGIN; UPDATE my_table SET x = 1; COMMIT;"),
+        r#"
+BEGIN;
+UPDATE my_table SET x = 1;
+COMMIT;
+"#
+        .trim()
+    );
+}
+
+#[test]
+#[ignore = "https://github.com/apache/datafusion-sqlparser-rs/issues/1850"]
+fn test_pretty_print_control_flow() {
+    assert_eq!(
+        prettify("IF x > 0 THEN SELECT 'positive'; ELSE SELECT 'negative'; END IF;"),
+        r#"
+IF x > 0 THEN
+  SELECT 'positive';
+ELSE
+  SELECT 'negative';
+END IF;
+"#
+        .trim()
+    );
+}
+
+#[test]
+#[ignore = "https://github.com/apache/datafusion-sqlparser-rs/issues/1850"]
+fn test_pretty_print_merge() {
+    assert_eq!(
+        prettify("MERGE INTO target_table t USING source_table s ON t.id = s.id WHEN MATCHED THEN UPDATE SET t.value = s.value WHEN NOT MATCHED THEN INSERT (id, value) VALUES (s.id, s.value)"),
+        r#"
+MERGE INTO target_table t
+USING source_table s ON t.id = s.id
+WHEN MATCHED THEN
+  UPDATE SET t.value = s.value
+WHEN NOT MATCHED THEN
+  INSERT (id, value) VALUES (s.id, s.value)
+"#
+        .trim()
+    );
+}
+
+#[test]
+#[ignore = "https://github.com/apache/datafusion-sqlparser-rs/issues/1850"]
+fn test_pretty_print_create_index() {
+    assert_eq!(
+        prettify("CREATE INDEX idx_name ON my_table (column1, column2)"),
+        r#"
+CREATE INDEX idx_name
+ON my_table (column1, column2)
+"#
+        .trim()
+    );
+}
+
+#[test]
+#[ignore = "https://github.com/apache/datafusion-sqlparser-rs/issues/1850"]
+fn test_pretty_print_explain() {
+    assert_eq!(
+        prettify("EXPLAIN ANALYZE SELECT * FROM my_table WHERE x > 0"),
+        r#"
+EXPLAIN ANALYZE
+SELECT
+  *
+FROM
+  my_table
+WHERE
+  x > 0
+"#
+        .trim()
+    );
+}

tests/sqlparser_clickhouse.rs

@@ -28,7 +28,7 @@ use test_utils::*;
 use sqlparser::ast::Expr::{BinaryOp, Identifier};
 use sqlparser::ast::SelectItem::UnnamedExpr;
 use sqlparser::ast::TableFactor::Table;
-use sqlparser::ast::Value::Number;
+use sqlparser::ast::Value::Boolean;
 use sqlparser::ast::*;
 use sqlparser::dialect::ClickHouseDialect;
 use sqlparser::dialect::GenericDialect;
@@ -55,14 +55,14 @@ fn parse_map_access_expr() {
                         "indexOf",
                         [
                             Expr::Identifier(Ident::new("string_names")),
-                            Expr::Value(Value::SingleQuotedString("endpoint".to_string()))
+                            Expr::value(Value::SingleQuotedString("endpoint".to_string()))
                         ]
                     ),
                 })],
             })],
             into: None,
             from: vec![TableWithJoins {
-                relation: table_from_name(ObjectName(vec![Ident::new("foos")])),
+                relation: table_from_name(ObjectName::from(vec![Ident::new("foos")])),
                 joins: vec![],
             }],
             lateral_views: vec![],
@@ -71,7 +71,7 @@ fn parse_map_access_expr() {
                 left: Box::new(BinaryOp {
                     left: Box::new(Identifier(Ident::new("id"))),
                     op: BinaryOperator::Eq,
-                    right: Box::new(Expr::Value(Value::SingleQuotedString("test".to_string()))),
+                    right: Box::new(Expr::value(Value::SingleQuotedString("test".to_string()))),
                 }),
                 op: BinaryOperator::And,
                 right: Box::new(BinaryOp {
@@ -82,13 +82,13 @@ fn parse_map_access_expr() {
                                 "indexOf",
                                 [
                                     Expr::Identifier(Ident::new("string_name")),
-                                    Expr::Value(Value::SingleQuotedString("app".to_string()))
+                                    Expr::value(Value::SingleQuotedString("app".to_string()))
                                 ]
                             ),
                         })],
                     }),
                     op: BinaryOperator::NotEq,
-                    right: Box::new(Expr::Value(Value::SingleQuotedString("foo".to_string()))),
+                    right: Box::new(Expr::value(Value::SingleQuotedString("foo".to_string()))),
                 }),
             }),
             group_by: GroupByExpr::Expressions(vec![], vec![]),
@@ -101,6 +101,7 @@ fn parse_map_access_expr() {
             qualify: None,
             value_table_mode: None,
             connect_by: None,
+            flavor: SelectFlavor::Standard,
         },
         select
     );
@@ -113,8 +114,8 @@ fn parse_array_expr() {
     assert_eq!(
         &Expr::Array(Array {
             elem: vec![
-                Expr::Value(Value::SingleQuotedString("1".to_string())),
-                Expr::Value(Value::SingleQuotedString("2".to_string())),
+                Expr::value(Value::SingleQuotedString("1".to_string())),
+                Expr::value(Value::SingleQuotedString("2".to_string())),
             ],
             named: false,
         }),
@@ -166,7 +167,10 @@ fn parse_delimited_identifiers() {
             version,
             ..
         } => {
-            assert_eq!(vec![Ident::with_quote('"', "a table")], name.0);
+            assert_eq!(
+                ObjectName::from(vec![Ident::with_quote('"', "a table")]),
+                name
+            );
             assert_eq!(Ident::with_quote('"', "alias"), alias.unwrap().name);
             assert!(args.is_none());
             assert!(with_hints.is_empty());
@@ -185,7 +189,7 @@ fn parse_delimited_identifiers() {
     );
     assert_eq!(
         &Expr::Function(Function {
-            name: ObjectName(vec![Ident::with_quote('"', "myfun")]),
+            name: ObjectName::from(vec![Ident::with_quote('"', "myfun")]),
             uses_odbc_syntax: false,
             parameters: FunctionArguments::None,
             args: FunctionArguments::List(FunctionArgumentList {
@@ -215,10 +219,14 @@ fn parse_delimited_identifiers() {
 
 #[test]
 fn parse_create_table() {
-    clickhouse().verified_stmt(r#"CREATE TABLE "x" ("a" "int") ENGINE=MergeTree ORDER BY ("x")"#);
-    clickhouse().verified_stmt(r#"CREATE TABLE "x" ("a" "int") ENGINE=MergeTree ORDER BY "x""#);
+    clickhouse().verified_stmt(r#"CREATE TABLE "x" ("a" "int") ENGINE = MergeTree ORDER BY ("x")"#);
+    clickhouse().verified_stmt(r#"CREATE TABLE "x" ("a" "int") ENGINE = MergeTree ORDER BY "x""#);
     clickhouse().verified_stmt(
-        r#"CREATE TABLE "x" ("a" "int") ENGINE=MergeTree ORDER BY "x" AS SELECT * FROM "t" WHERE true"#,
+        r#"CREATE TABLE "x" ("a" "int") ENGINE = MergeTree ORDER BY "x" AS SELECT * FROM "t" WHERE true"#,
+    );
+    clickhouse().one_statement_parses_to(
+        "CREATE TABLE x (a int) ENGINE = MergeTree() ORDER BY a",
+        "CREATE TABLE x (a INT) ENGINE = MergeTree ORDER BY a",
     );
 }
 
@@ -302,7 +310,7 @@ fn parse_alter_table_add_projection() {
         Statement::AlterTable {
             name, operations, ..
         } => {
-            assert_eq!(name, ObjectName(vec!["t0".into()]));
+            assert_eq!(name, ObjectName::from(vec!["t0".into()]));
             assert_eq!(1, operations.len());
             assert_eq!(
                 operations[0],
@@ -319,12 +327,14 @@ fn parse_alter_table_add_projection() {
                             vec![]
                         )),
                         order_by: Some(OrderBy {
-                            exprs: vec![OrderByExpr {
+                            kind: OrderByKind::Expressions(vec![OrderByExpr {
                                 expr: Identifier(Ident::new("b")),
-                                asc: None,
-                                nulls_first: None,
+                                options: OrderByOptions {
+                                    asc: None,
+                                    nulls_first: None,
+                                },
                                 with_fill: None,
-                            }],
+                            }]),
                             interpolate: None,
                         }),
                     }
@@ -372,7 +382,7 @@ fn parse_alter_table_drop_projection() {
         Statement::AlterTable {
             name, operations, ..
         } => {
-            assert_eq!(name, ObjectName(vec!["t0".into()]));
+            assert_eq!(name, ObjectName::from(vec!["t0".into()]));
             assert_eq!(1, operations.len());
             assert_eq!(
                 operations[0],
@@ -405,7 +415,7 @@ fn parse_alter_table_clear_and_materialize_projection() {
             Statement::AlterTable {
                 name, operations, ..
             } => {
-                assert_eq!(name, ObjectName(vec!["t0".into()]));
+                assert_eq!(name, ObjectName::from(vec!["t0".into()]));
                 assert_eq!(1, operations.len());
                 assert_eq!(
                     operations[0],
@@ -524,7 +534,6 @@ fn column_def(name: Ident, data_type: DataType) -> ColumnDef {
     ColumnDef {
         name,
         data_type,
-        collation: None,
         options: vec![],
     }
 }
@@ -549,7 +558,7 @@ fn parse_clickhouse_data_types() {
 
     match clickhouse_and_generic().one_statement_parses_to(sql, &canonical_sql) {
         Statement::CreateTable(CreateTable { name, columns, .. }) => {
-            assert_eq!(name, ObjectName(vec!["table".into()]));
+            assert_eq!(name, ObjectName::from(vec!["table".into()]));
             assert_eq!(
                 columns,
                 vec![
@@ -584,13 +593,13 @@ fn parse_clickhouse_data_types() {
 
 #[test]
 fn parse_create_table_with_nullable() {
-    let sql = r#"CREATE TABLE table (k UInt8, `a` Nullable(String), `b` Nullable(DateTime64(9, 'UTC')), c Nullable(DateTime64(9)), d Date32 NULL) ENGINE=MergeTree ORDER BY (`k`)"#;
+    let sql = r#"CREATE TABLE table (k UInt8, `a` Nullable(String), `b` Nullable(DateTime64(9, 'UTC')), c Nullable(DateTime64(9)), d Date32 NULL) ENGINE = MergeTree ORDER BY (`k`)"#;
     // ClickHouse has a case-sensitive definition of data type, but canonical representation is not
     let canonical_sql = sql.replace("String", "STRING");
 
     match clickhouse_and_generic().one_statement_parses_to(sql, &canonical_sql) {
         Statement::CreateTable(CreateTable { name, columns, .. }) => {
-            assert_eq!(name, ObjectName(vec!["table".into()]));
+            assert_eq!(name, ObjectName::from(vec!["table".into()]));
             assert_eq!(
                 columns,
                 vec![
@@ -613,7 +622,6 @@ fn parse_create_table_with_nullable() {
                     ColumnDef {
                         name: "d".into(),
                         data_type: DataType::Date32,
-                        collation: None,
                         options: vec![ColumnOptionDef {
                             name: None,
                             option: ColumnOption::Null
@@ -639,7 +647,7 @@ fn parse_create_table_with_nested_data_types() {
 
     match clickhouse().one_statement_parses_to(sql, "") {
         Statement::CreateTable(CreateTable { name, columns, .. }) => {
-            assert_eq!(name, ObjectName(vec!["table".into()]));
+            assert_eq!(name, ObjectName::from(vec!["table".into()]));
             assert_eq!(
                 columns,
                 vec![
@@ -657,7 +665,6 @@ fn parse_create_table_with_nested_data_types() {
                                 DataType::LowCardinality(Box::new(DataType::String(None)))
                             )
                         ]),
-                        collation: None,
                         options: vec![],
                     },
                     ColumnDef {
@@ -666,15 +673,16 @@ fn parse_create_table_with_nested_data_types() {
                             DataType::Tuple(vec![
                                 StructField {
                                     field_name: None,
-                                    field_type: DataType::FixedString(128)
+                                    field_type: DataType::FixedString(128),
+                                    options: None,
                                 },
                                 StructField {
                                     field_name: None,
-                                    field_type: DataType::Int128
+                                    field_type: DataType::Int128,
+                                    options: None,
                                 }
                             ])
                         ))),
-                        collation: None,
                         options: vec![],
                     },
                     ColumnDef {
@@ -683,15 +691,16 @@ fn parse_create_table_with_nested_data_types() {
                             StructField {
                                 field_name: Some("a".into()),
                                 field_type: DataType::Datetime64(9, None),
+                                options: None,
                             },
                             StructField {
                                 field_name: Some("b".into()),
                                 field_type: DataType::Array(ArrayElemTypeDef::Parenthesis(
                                     Box::new(DataType::Uuid)
-                                ))
+                                )),
+                                options: None,
                             },
                         ]),
-                        collation: None,
                         options: vec![],
                     },
                     ColumnDef {
@@ -700,7 +709,6 @@ fn parse_create_table_with_nested_data_types() {
                             Box::new(DataType::String(None)),
                             Box::new(DataType::UInt16)
                         ),
-                        collation: None,
                         options: vec![],
                     },
                 ]
@@ -714,14 +722,14 @@ fn parse_create_table_with_nested_data_types() {
 fn parse_create_table_with_primary_key() {
     match clickhouse_and_generic().verified_stmt(concat!(
         r#"CREATE TABLE db.table (`i` INT, `k` INT)"#,
-        " ENGINE=SharedMergeTree('/clickhouse/tables/{uuid}/{shard}', '{replica}')",
+        " ENGINE = SharedMergeTree('/clickhouse/tables/{uuid}/{shard}', '{replica}')",
         " PRIMARY KEY tuple(i)",
         " ORDER BY tuple(i)",
     )) {
         Statement::CreateTable(CreateTable {
             name,
             columns,
-            engine,
+            table_options,
             primary_key,
             order_by,
             ..
@@ -732,30 +740,35 @@ fn parse_create_table_with_primary_key() {
                     ColumnDef {
                         name: Ident::with_quote('`', "i"),
                         data_type: DataType::Int(None),
-                        collation: None,
                         options: vec![],
                     },
                     ColumnDef {
                         name: Ident::with_quote('`', "k"),
                         data_type: DataType::Int(None),
-                        collation: None,
                         options: vec![],
                     },
                 ],
                 columns
             );
-            assert_eq!(
-                engine,
-                Some(TableEngine {
-                    name: "SharedMergeTree".to_string(),
-                    parameters: Some(vec![
+
+            let plain_options = match table_options {
+                CreateTableOptions::Plain(options) => options,
+                _ => unreachable!(),
+            };
+
+            assert!(plain_options.contains(&SqlOption::NamedParenthesizedList(
+                NamedParenthesizedList {
+                    key: Ident::new("ENGINE"),
+                    name: Some(Ident::new("SharedMergeTree")),
+                    values: vec![
                         Ident::with_quote('\'', "/clickhouse/tables/{uuid}/{shard}"),
                         Ident::with_quote('\'', "{replica}"),
-                    ]),
-                })
-            );
+                    ]
+                }
+            )));
+
             fn assert_function(actual: &Function, name: &str, arg: &str) -> bool {
-                assert_eq!(actual.name, ObjectName(vec![Ident::new(name)]));
+                assert_eq!(actual.name, ObjectName::from(vec![Ident::new(name)]));
                 assert_eq!(
                     actual.args,
                     FunctionArguments::List(FunctionArgumentList {
@@ -800,7 +813,7 @@ fn parse_create_table_with_variant_default_expressions() {
         " b DATETIME EPHEMERAL now(),",
         " c DATETIME EPHEMERAL,",
         " d STRING ALIAS toString(c)",
-        ") ENGINE=MergeTree"
+        ") ENGINE = MergeTree"
     );
     match clickhouse_and_generic().verified_stmt(sql) {
         Statement::CreateTable(CreateTable { columns, .. }) => {
@@ -810,11 +823,10 @@ fn parse_create_table_with_variant_default_expressions() {
                     ColumnDef {
                         name: Ident::new("a"),
                         data_type: DataType::Datetime(None),
-                        collation: None,
                         options: vec![ColumnOptionDef {
                             name: None,
                             option: ColumnOption::Materialized(Expr::Function(Function {
-                                name: ObjectName(vec![Ident::new("now")]),
+                                name: ObjectName::from(vec![Ident::new("now")]),
                                 uses_odbc_syntax: false,
                                 args: FunctionArguments::List(FunctionArgumentList {
                                     args: vec![],
@@ -832,11 +844,10 @@ fn parse_create_table_with_variant_default_expressions() {
                     ColumnDef {
                         name: Ident::new("b"),
                         data_type: DataType::Datetime(None),
-                        collation: None,
                         options: vec![ColumnOptionDef {
                             name: None,
                             option: ColumnOption::Ephemeral(Some(Expr::Function(Function {
-                                name: ObjectName(vec![Ident::new("now")]),
+                                name: ObjectName::from(vec![Ident::new("now")]),
                                 uses_odbc_syntax: false,
                                 args: FunctionArguments::List(FunctionArgumentList {
                                     args: vec![],
@@ -854,7 +865,6 @@ fn parse_create_table_with_variant_default_expressions() {
                     ColumnDef {
                         name: Ident::new("c"),
                         data_type: DataType::Datetime(None),
-                        collation: None,
                         options: vec![ColumnOptionDef {
                             name: None,
                             option: ColumnOption::Ephemeral(None)
@@ -863,11 +873,10 @@ fn parse_create_table_with_variant_default_expressions() {
                     ColumnDef {
                         name: Ident::new("d"),
                         data_type: DataType::String(None),
-                        collation: None,
                         options: vec![ColumnOptionDef {
                             name: None,
                             option: ColumnOption::Alias(Expr::Function(Function {
-                                name: ObjectName(vec![Ident::new("toString")]),
+                                name: ObjectName::from(vec![Ident::new("toString")]),
                                 uses_odbc_syntax: false,
                                 args: FunctionArguments::List(FunctionArgumentList {
                                     args: vec![FunctionArg::Unnamed(FunctionArgExpr::Expr(
@@ -895,33 +904,33 @@ fn parse_create_table_with_variant_default_expressions() {
 fn parse_create_view_with_fields_data_types() {
     match clickhouse().verified_stmt(r#"CREATE VIEW v (i "int", f "String") AS SELECT * FROM t"#) {
         Statement::CreateView { name, columns, .. } => {
-            assert_eq!(name, ObjectName(vec!["v".into()]));
+            assert_eq!(name, ObjectName::from(vec!["v".into()]));
             assert_eq!(
                 columns,
                 vec![
                     ViewColumnDef {
                         name: "i".into(),
                         data_type: Some(DataType::Custom(
-                            ObjectName(vec![Ident {
+                            ObjectName::from(vec![Ident {
                                 value: "int".into(),
                                 quote_style: Some('"'),
                                 span: Span::empty(),
                             }]),
                             vec![]
                         )),
-                        options: None
+                        options: None,
                     },
                     ViewColumnDef {
                         name: "f".into(),
                         data_type: Some(DataType::Custom(
-                            ObjectName(vec![Ident {
+                            ObjectName::from(vec![Ident {
                                 value: "String".into(),
                                 quote_style: Some('"'),
                                 span: Span::empty(),
                             }]),
                             vec![]
                         )),
-                        options: None
+                        options: None,
                     },
                 ]
             );
@@ -950,42 +959,113 @@ fn parse_limit_by() {
     clickhouse_and_generic().verified_stmt(
         r#"SELECT * FROM default.last_asset_runs_mv ORDER BY created_at DESC LIMIT 1 BY asset, toStartOfDay(created_at)"#,
     );
+    clickhouse_and_generic().parse_sql_statements(
+        r#"SELECT * FROM default.last_asset_runs_mv ORDER BY created_at DESC BY asset, toStartOfDay(created_at)"#,
+    ).expect_err("BY without LIMIT");
+    clickhouse_and_generic()
+        .parse_sql_statements("SELECT * FROM T OFFSET 5 BY foo")
+        .expect_err("BY with OFFSET but without LIMIT");
 }
 
 #[test]
 fn parse_settings_in_query() {
-    match clickhouse_and_generic()
-        .verified_stmt(r#"SELECT * FROM t SETTINGS max_threads = 1, max_block_size = 10000"#)
-    {
-        Statement::Query(query) => {
-            assert_eq!(
-                query.settings,
-                Some(vec![
-                    Setting {
-                        key: Ident::new("max_threads"),
-                        value: Number("1".parse().unwrap(), false)
-                    },
-                    Setting {
-                        key: Ident::new("max_block_size"),
-                        value: Number("10000".parse().unwrap(), false)
-                    },
-                ])
-            );
+    fn check_settings(sql: &str, expected: Vec<Setting>) {
+        match clickhouse_and_generic().verified_stmt(sql) {
+            Statement::Query(q) => {
+                assert_eq!(q.settings, Some(expected));
+            }
+            _ => unreachable!(),
         }
-        _ => unreachable!(),
+    }
+
+    for (sql, expected_settings) in [
+        (
+            r#"SELECT * FROM t SETTINGS max_threads = 1, max_block_size = 10000"#,
+            vec![
+                Setting {
+                    key: Ident::new("max_threads"),
+                    value: Expr::value(number("1")),
+                },
+                Setting {
+                    key: Ident::new("max_block_size"),
+                    value: Expr::value(number("10000")),
+                },
+            ],
+        ),
+        (
+            r#"SELECT * FROM t SETTINGS additional_table_filters = {'table_1': 'x != 2'}"#,
+            vec![Setting {
+                key: Ident::new("additional_table_filters"),
+                value: Expr::Dictionary(vec![DictionaryField {
+                    key: Ident::with_quote('\'', "table_1"),
+                    value: Expr::value(single_quoted_string("x != 2")).into(),
+                }]),
+            }],
+        ),
+        (
+            r#"SELECT * FROM t SETTINGS additional_result_filter = 'x != 2', query_plan_optimize_lazy_materialization = false"#,
+            vec![
+                Setting {
+                    key: Ident::new("additional_result_filter"),
+                    value: Expr::value(single_quoted_string("x != 2")),
+                },
+                Setting {
+                    key: Ident::new("query_plan_optimize_lazy_materialization"),
+                    value: Expr::value(Boolean(false)),
+                },
+            ],
+        ),
+    ] {
+        check_settings(sql, expected_settings);
     }
 
     let invalid_cases = vec![
-        "SELECT * FROM t SETTINGS a",
-        "SELECT * FROM t SETTINGS a=",
-        "SELECT * FROM t SETTINGS a=1, b",
-        "SELECT * FROM t SETTINGS a=1, b=",
-        "SELECT * FROM t SETTINGS a=1, b=c",
+        ("SELECT * FROM t SETTINGS a", "Expected: =, found: EOF"),
+        (
+            "SELECT * FROM t SETTINGS a=",
+            "Expected: an expression, found: EOF",
+        ),
+        ("SELECT * FROM t SETTINGS a=1, b", "Expected: =, found: EOF"),
+        (
+            "SELECT * FROM t SETTINGS a=1, b=",
+            "Expected: an expression, found: EOF",
+        ),
+        (
+            "SELECT * FROM t SETTINGS a = {",
+            "Expected: identifier, found: EOF",
+        ),
+        (
+            "SELECT * FROM t SETTINGS a = {'b'",
+            "Expected: :, found: EOF",
+        ),
+        (
+            "SELECT * FROM t SETTINGS a = {'b': ",
+            "Expected: an expression, found: EOF",
+        ),
+        (
+            "SELECT * FROM t SETTINGS a = {'b': 'c',}",
+            "Expected: identifier, found: }",
+        ),
+        (
+            "SELECT * FROM t SETTINGS a = {'b': 'c', 'd'}",
+            "Expected: :, found: }",
+        ),
+        (
+            "SELECT * FROM t SETTINGS a = {'b': 'c', 'd': }",
+            "Expected: an expression, found: }",
+        ),
+        (
+            "SELECT * FROM t SETTINGS a = {ANY(b)}",
+            "Expected: :, found: (",
+        ),
     ];
-    for sql in invalid_cases {
-        clickhouse_and_generic()
-            .parse_sql_statements(sql)
-            .expect_err("Expected: SETTINGS key = value, found: ");
+    for (sql, error_msg) in invalid_cases {
+        assert_eq!(
+            clickhouse_and_generic()
+                .parse_sql_statements(sql)
+                .unwrap_err(),
+            ParserError(error_msg.to_string())
+        );
     }
 }
 #[test]
@@ -1022,17 +1102,15 @@ fn parse_select_parametric_function() {
                     assert_eq!(parameters.args.len(), 2);
                     assert_eq!(
                         parameters.args[0],
-                        FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::Value(Value::Number(
-                            "0.5".parse().unwrap(),
-                            false
-                        ))))
+                        FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::Value(
+                            (Value::Number("0.5".parse().unwrap(), false)).with_empty_span()
+                        )))
                     );
                     assert_eq!(
                         parameters.args[1],
-                        FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::Value(Value::Number(
-                            "0.6".parse().unwrap(),
-                            false
-                        ))))
+                        FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::Value(
+                            (Value::Number("0.6".parse().unwrap(), false)).with_empty_span()
+                        )))
                     );
                 }
                 _ => unreachable!(),
@@ -1065,61 +1143,6 @@ fn parse_create_materialized_view() {
     clickhouse_and_generic().verified_stmt(sql);
 }
 
-#[test]
-fn parse_group_by_with_modifier() {
-    let clauses = ["x", "a, b", "ALL"];
-    let modifiers = [
-        "WITH ROLLUP",
-        "WITH CUBE",
-        "WITH TOTALS",
-        "WITH ROLLUP WITH CUBE",
-    ];
-    let expected_modifiers = [
-        vec![GroupByWithModifier::Rollup],
-        vec![GroupByWithModifier::Cube],
-        vec![GroupByWithModifier::Totals],
-        vec![GroupByWithModifier::Rollup, GroupByWithModifier::Cube],
-    ];
-    for clause in &clauses {
-        for (modifier, expected_modifier) in modifiers.iter().zip(expected_modifiers.iter()) {
-            let sql = format!("SELECT * FROM t GROUP BY {clause} {modifier}");
-            match clickhouse_and_generic().verified_stmt(&sql) {
-                Statement::Query(query) => {
-                    let group_by = &query.body.as_select().unwrap().group_by;
-                    if clause == &"ALL" {
-                        assert_eq!(group_by, &GroupByExpr::All(expected_modifier.to_vec()));
-                    } else {
-                        assert_eq!(
-                            group_by,
-                            &GroupByExpr::Expressions(
-                                clause
-                                    .split(", ")
-                                    .map(|c| Identifier(Ident::new(c)))
-                                    .collect(),
-                                expected_modifier.to_vec()
-                            )
-                        );
-                    }
-                }
-                _ => unreachable!(),
-            }
-        }
-    }
-
-    // invalid cases
-    let invalid_cases = [
-        "SELECT * FROM t GROUP BY x WITH",
-        "SELECT * FROM t GROUP BY x WITH ROLLUP CUBE",
-        "SELECT * FROM t GROUP BY x WITH WITH ROLLUP",
-        "SELECT * FROM t GROUP BY WITH ROLLUP",
-    ];
-    for sql in invalid_cases {
-        clickhouse_and_generic()
-            .parse_sql_statements(sql)
-            .expect_err("Expected: one of ROLLUP or CUBE or TOTALS, found: WITH");
-    }
-}
-
 #[test]
 fn parse_select_order_by_with_fill_interpolate() {
     let sql = "SELECT id, fname, lname FROM customer WHERE id < 5 \
@@ -1131,42 +1154,53 @@ fn parse_select_order_by_with_fill_interpolate() {
     let select = clickhouse().verified_query(sql);
     assert_eq!(
         OrderBy {
-            exprs: vec![
+            kind: OrderByKind::Expressions(vec![
                 OrderByExpr {
                     expr: Expr::Identifier(Ident::new("fname")),
-                    asc: Some(true),
-                    nulls_first: Some(true),
+                    options: OrderByOptions {
+                        asc: Some(true),
+                        nulls_first: Some(true),
+                    },
                     with_fill: Some(WithFill {
-                        from: Some(Expr::Value(number("10"))),
-                        to: Some(Expr::Value(number("20"))),
-                        step: Some(Expr::Value(number("2"))),
+                        from: Some(Expr::value(number("10"))),
+                        to: Some(Expr::value(number("20"))),
+                        step: Some(Expr::value(number("2"))),
                     }),
                 },
                 OrderByExpr {
                     expr: Expr::Identifier(Ident::new("lname")),
-                    asc: Some(false),
-                    nulls_first: Some(false),
+                    options: OrderByOptions {
+                        asc: Some(false),
+                        nulls_first: Some(false),
+                    },
                     with_fill: Some(WithFill {
-                        from: Some(Expr::Value(number("30"))),
-                        to: Some(Expr::Value(number("40"))),
-                        step: Some(Expr::Value(number("3"))),
+                        from: Some(Expr::value(number("30"))),
+                        to: Some(Expr::value(number("40"))),
+                        step: Some(Expr::value(number("3"))),
                     }),
                 },
-            ],
+            ]),
             interpolate: Some(Interpolate {
                 exprs: Some(vec![InterpolateExpr {
                     column: Ident::new("col1"),
                     expr: Some(Expr::BinaryOp {
                         left: Box::new(Expr::Identifier(Ident::new("col1"))),
                         op: BinaryOperator::Plus,
-                        right: Box::new(Expr::Value(number("1"))),
+                        right: Box::new(Expr::value(number("1"))),
                     }),
                 }])
             })
         },
         select.order_by.expect("ORDER BY expected")
     );
-    assert_eq!(Some(Expr::Value(number("2"))), select.limit);
+    assert_eq!(
+        select.limit_clause,
+        Some(LimitClause::LimitOffset {
+            limit: Some(Expr::value(number("2"))),
+            offset: None,
+            limit_by: vec![]
+        })
+    );
 }
 
 #[test]
@@ -1207,11 +1241,15 @@ fn parse_with_fill() {
     let select = clickhouse().verified_query(sql);
     assert_eq!(
         Some(WithFill {
-            from: Some(Expr::Value(number("10"))),
-            to: Some(Expr::Value(number("20"))),
-            step: Some(Expr::Value(number("2"))),
-        }),
-        select.order_by.expect("ORDER BY expected").exprs[0].with_fill
+            from: Some(Expr::value(number("10"))),
+            to: Some(Expr::value(number("20"))),
+            step: Some(Expr::value(number("2"))),
+        })
+        .as_ref(),
+        match select.order_by.expect("ORDER BY expected").kind {
+            OrderByKind::Expressions(ref exprs) => exprs[0].with_fill.as_ref(),
+            _ => None,
+        }
     );
 }
 
@@ -1246,7 +1284,7 @@ fn parse_interpolate_body_with_columns() {
                     expr: Some(Expr::BinaryOp {
                         left: Box::new(Expr::Identifier(Ident::new("col1"))),
                         op: BinaryOperator::Plus,
-                        right: Box::new(Expr::Value(number("1"))),
+                        right: Box::new(Expr::value(number("1"))),
                     }),
                 },
                 InterpolateExpr {
@@ -1258,12 +1296,17 @@ fn parse_interpolate_body_with_columns() {
                     expr: Some(Expr::BinaryOp {
                         left: Box::new(Expr::Identifier(Ident::new("col4"))),
                         op: BinaryOperator::Plus,
-                        right: Box::new(Expr::Value(number("4"))),
+                        right: Box::new(Expr::value(number("4"))),
                     }),
                 },
             ])
-        }),
-        select.order_by.expect("ORDER BY expected").interpolate
+        })
+        .as_ref(),
+        select
+            .order_by
+            .expect("ORDER BY expected")
+            .interpolate
+            .as_ref()
     );
 }
 
@@ -1272,8 +1315,12 @@ fn parse_interpolate_without_body() {
     let sql = "SELECT fname FROM customer ORDER BY fname WITH FILL INTERPOLATE";
     let select = clickhouse().verified_query(sql);
     assert_eq!(
-        Some(Interpolate { exprs: None }),
-        select.order_by.expect("ORDER BY expected").interpolate
+        Some(Interpolate { exprs: None }).as_ref(),
+        select
+            .order_by
+            .expect("ORDER BY expected")
+            .interpolate
+            .as_ref()
     );
 }
 
@@ -1284,8 +1331,13 @@ fn parse_interpolate_with_empty_body() {
     assert_eq!(
         Some(Interpolate {
             exprs: Some(vec![])
-        }),
-        select.order_by.expect("ORDER BY expected").interpolate
+        })
+        .as_ref(),
+        select
+            .order_by
+            .expect("ORDER BY expected")
+            .interpolate
+            .as_ref()
     );
 }
 
@@ -1299,7 +1351,9 @@ fn test_prewhere() {
                 Some(&BinaryOp {
                     left: Box::new(Identifier(Ident::new("x"))),
                     op: BinaryOperator::Eq,
-                    right: Box::new(Expr::Value(Value::Number("1".parse().unwrap(), false))),
+                    right: Box::new(Expr::Value(
+                        (Value::Number("1".parse().unwrap(), false)).with_empty_span()
+                    )),
                 })
             );
             let selection = query.as_ref().body.as_select().unwrap().selection.as_ref();
@@ -1308,7 +1362,9 @@ fn test_prewhere() {
                 Some(&BinaryOp {
                     left: Box::new(Identifier(Ident::new("y"))),
                     op: BinaryOperator::Eq,
-                    right: Box::new(Expr::Value(Value::Number("2".parse().unwrap(), false))),
+                    right: Box::new(Expr::Value(
+                        (Value::Number("2".parse().unwrap(), false)).with_empty_span()
+                    )),
                 })
             );
         }
@@ -1324,13 +1380,17 @@ fn test_prewhere() {
                     left: Box::new(BinaryOp {
                         left: Box::new(Identifier(Ident::new("x"))),
                         op: BinaryOperator::Eq,
-                        right: Box::new(Expr::Value(Value::Number("1".parse().unwrap(), false))),
+                        right: Box::new(Expr::Value(
+                            (Value::Number("1".parse().unwrap(), false)).with_empty_span()
+                        )),
                     }),
                     op: BinaryOperator::And,
                     right: Box::new(BinaryOp {
                         left: Box::new(Identifier(Ident::new("y"))),
                         op: BinaryOperator::Eq,
-                        right: Box::new(Expr::Value(Value::Number("2".parse().unwrap(), false))),
+                        right: Box::new(Expr::Value(
+                            (Value::Number("2".parse().unwrap(), false)).with_empty_span()
+                        )),
                     }),
                 })
             );
@@ -1354,16 +1414,16 @@ fn parse_use() {
     for object_name in &valid_object_names {
         // Test single identifier without quotes
         assert_eq!(
-            clickhouse().verified_stmt(&format!("USE {}", object_name)),
-            Statement::Use(Use::Object(ObjectName(vec![Ident::new(
+            clickhouse().verified_stmt(&format!("USE {object_name}")),
+            Statement::Use(Use::Object(ObjectName::from(vec![Ident::new(
                 object_name.to_string()
             )])))
         );
         for &quote in &quote_styles {
             // Test single identifier with different type of quotes
             assert_eq!(
-                clickhouse().verified_stmt(&format!("USE {0}{1}{0}", quote, object_name)),
-                Statement::Use(Use::Object(ObjectName(vec![Ident::with_quote(
+                clickhouse().verified_stmt(&format!("USE {quote}{object_name}{quote}")),
+                Statement::Use(Use::Object(ObjectName::from(vec![Ident::with_quote(
                     quote,
                     object_name.to_string(),
                 )])))
@@ -1376,7 +1436,7 @@ fn parse_use() {
 fn test_query_with_format_clause() {
     let format_options = vec!["TabSeparated", "JSONCompact", "NULL"];
     for format in &format_options {
-        let sql = format!("SELECT * FROM t FORMAT {}", format);
+        let sql = format!("SELECT * FROM t FORMAT {format}");
         match clickhouse_and_generic().verified_stmt(&sql) {
             Statement::Query(query) => {
                 if *format == "NULL" {
@@ -1438,10 +1498,9 @@ fn parse_create_table_on_commit_and_as_query() {
             assert_eq!(on_commit, Some(OnCommit::PreserveRows));
             assert_eq!(
                 query.unwrap().body.as_select().unwrap().projection,
-                vec![UnnamedExpr(Expr::Value(Value::Number(
-                    "1".parse().unwrap(),
-                    false
-                )))]
+                vec![UnnamedExpr(Expr::Value(
+                    (Value::Number("1".parse().unwrap(), false)).with_empty_span()
+                ))]
             );
         }
         _ => unreachable!(),
@@ -1454,9 +1513,9 @@ fn parse_freeze_and_unfreeze_partition() {
     for operation_name in &["FREEZE", "UNFREEZE"] {
         let sql = format!("ALTER TABLE t {operation_name} PARTITION '2024-08-14'");
 
-        let expected_partition = Partition::Expr(Expr::Value(Value::SingleQuotedString(
-            "2024-08-14".to_string(),
-        )));
+        let expected_partition = Partition::Expr(Expr::Value(
+            Value::SingleQuotedString("2024-08-14".to_string()).with_empty_span(),
+        ));
         match clickhouse_and_generic().verified_stmt(&sql) {
             Statement::AlterTable { operations, .. } => {
                 assert_eq!(operations.len(), 1);
@@ -1484,9 +1543,9 @@ fn parse_freeze_and_unfreeze_partition() {
         match clickhouse_and_generic().verified_stmt(&sql) {
             Statement::AlterTable { operations, .. } => {
                 assert_eq!(operations.len(), 1);
-                let expected_partition = Partition::Expr(Expr::Value(Value::SingleQuotedString(
-                    "2024-08-14".to_string(),
-                )));
+                let expected_partition = Partition::Expr(Expr::Value(
+                    Value::SingleQuotedString("2024-08-14".to_string()).with_empty_span(),
+                ));
                 let expected_operation = if operation_name == &"FREEZE" {
                     AlterTableOperation::FreezePartition {
                         partition: expected_partition,
@@ -1560,11 +1619,11 @@ fn parse_select_table_function_settings() {
             settings: Some(vec![
                 Setting {
                     key: "s0".into(),
-                    value: Value::Number("3".parse().unwrap(), false),
+                    value: Expr::value(number("3")),
                 },
                 Setting {
                     key: "s1".into(),
-                    value: Value::SingleQuotedString("s".into()),
+                    value: Expr::value(single_quoted_string("s")),
                 },
             ]),
         },
@@ -1585,11 +1644,11 @@ fn parse_select_table_function_settings() {
             settings: Some(vec![
                 Setting {
                     key: "s0".into(),
-                    value: Value::Number("3".parse().unwrap(), false),
+                    value: Expr::value(number("3")),
                 },
                 Setting {
                     key: "s1".into(),
-                    value: Value::SingleQuotedString("s".into()),
+                    value: Expr::value(single_quoted_string("s")),
                 },
             ]),
         },
@@ -1599,7 +1658,6 @@ fn parse_select_table_function_settings() {
         "SELECT * FROM t(SETTINGS a=)",
         "SELECT * FROM t(SETTINGS a=1, b)",
         "SELECT * FROM t(SETTINGS a=1, b=)",
-        "SELECT * FROM t(SETTINGS a=1, b=c)",
     ];
     for sql in invalid_cases {
         clickhouse_and_generic()

tests/sqlparser_custom_dialect.rs

@@ -41,7 +41,7 @@ fn custom_prefix_parser() -> Result<(), ParserError> {
 
         fn parse_prefix(&self, parser: &mut Parser) -> Option<Result<Expr, ParserError>> {
             if parser.consume_token(&Token::Number("1".to_string(), false)) {
-                Some(Ok(Expr::Value(Value::Null)))
+                Some(Ok(Expr::Value(Value::Null.with_empty_span())))
             } else {
                 None
             }

tests/sqlparser_databricks.rs

@@ -15,9 +15,11 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use sqlparser::ast::helpers::attached_token::AttachedToken;
 use sqlparser::ast::*;
 use sqlparser::dialect::{DatabricksDialect, GenericDialect};
 use sqlparser::parser::ParserError;
+use sqlparser::tokenizer::Span;
 use test_utils::*;
 
 #[macro_use]
@@ -47,7 +49,9 @@ fn test_databricks_identifiers() {
         databricks()
             .verified_only_select(r#"SELECT "Ä""#)
             .projection[0],
-        SelectItem::UnnamedExpr(Expr::Value(Value::DoubleQuotedString("Ä".to_owned())))
+        SelectItem::UnnamedExpr(Expr::Value(
+            (Value::DoubleQuotedString("Ä".to_owned())).with_empty_span()
+        ))
     );
 }
 
@@ -62,9 +66,9 @@ fn test_databricks_exists() {
                 call(
                     "array",
                     [
-                        Expr::Value(number("1")),
-                        Expr::Value(number("2")),
-                        Expr::Value(number("3"))
+                        Expr::value(number("1")),
+                        Expr::value(number("2")),
+                        Expr::value(number("3"))
                     ]
                 ),
                 Expr::Lambda(LambdaFunction {
@@ -99,40 +103,44 @@ fn test_databricks_lambdas() {
                 call(
                     "array",
                     [
-                        Expr::Value(Value::SingleQuotedString("Hello".to_owned())),
-                        Expr::Value(Value::SingleQuotedString("World".to_owned()))
+                        Expr::value(Value::SingleQuotedString("Hello".to_owned())),
+                        Expr::value(Value::SingleQuotedString("World".to_owned()))
                     ]
                 ),
                 Expr::Lambda(LambdaFunction {
                     params: OneOrManyWithParens::Many(vec![Ident::new("p1"), Ident::new("p2")]),
                     body: Box::new(Expr::Case {
+                        case_token: AttachedToken::empty(),
+                        end_token: AttachedToken::empty(),
                         operand: None,
                         conditions: vec![
-                            Expr::BinaryOp {
-                                left: Box::new(Expr::Identifier(Ident::new("p1"))),
-                                op: BinaryOperator::Eq,
-                                right: Box::new(Expr::Identifier(Ident::new("p2")))
+                            CaseWhen {
+                                condition: Expr::BinaryOp {
+                                    left: Box::new(Expr::Identifier(Ident::new("p1"))),
+                                    op: BinaryOperator::Eq,
+                                    right: Box::new(Expr::Identifier(Ident::new("p2")))
+                                },
+                                result: Expr::value(number("0"))
+                            },
+                            CaseWhen {
+                                condition: Expr::BinaryOp {
+                                    left: Box::new(call(
+                                        "reverse",
+                                        [Expr::Identifier(Ident::new("p1"))]
+                                    )),
+                                    op: BinaryOperator::Lt,
+                                    right: Box::new(call(
+                                        "reverse",
+                                        [Expr::Identifier(Ident::new("p2"))]
+                                    )),
+                                },
+                                result: Expr::UnaryOp {
+                                    op: UnaryOperator::Minus,
+                                    expr: Box::new(Expr::value(number("1")))
+                                }
                             },
-                            Expr::BinaryOp {
-                                left: Box::new(call(
-                                    "reverse",
-                                    [Expr::Identifier(Ident::new("p1"))]
-                                )),
-                                op: BinaryOperator::Lt,
-                                right: Box::new(call(
-                                    "reverse",
-                                    [Expr::Identifier(Ident::new("p2"))]
-                                ))
-                            }
                         ],
-                        results: vec![
-                            Expr::Value(number("0")),
-                            Expr::UnaryOp {
-                                op: UnaryOperator::Minus,
-                                expr: Box::new(Expr::Value(number("1")))
-                            }
-                        ],
-                        else_result: Some(Box::new(Expr::Value(number("1"))))
+                        else_result: Some(Box::new(Expr::value(number("1"))))
                     })
                 })
             ]
@@ -152,12 +160,12 @@ fn test_values_clause() {
         explicit_row: false,
         rows: vec![
             vec![
-                Expr::Value(Value::DoubleQuotedString("one".to_owned())),
-                Expr::Value(number("1")),
+                Expr::Value((Value::DoubleQuotedString("one".to_owned())).with_empty_span()),
+                Expr::value(number("1")),
             ],
             vec![
-                Expr::Value(Value::SingleQuotedString("two".to_owned())),
-                Expr::Value(number("2")),
+                Expr::Value((Value::SingleQuotedString("two".to_owned())).with_empty_span()),
+                Expr::value(number("2")),
             ],
         ],
     };
@@ -185,7 +193,9 @@ fn test_values_clause() {
         "SELECT * FROM values",
     ));
     assert_eq!(
-        Some(&table_from_name(ObjectName(vec![Ident::new("values")]))),
+        Some(&table_from_name(ObjectName::from(vec![Ident::new(
+            "values"
+        )]))),
         query
             .body
             .as_select()
@@ -204,16 +214,16 @@ fn parse_use() {
     for object_name in &valid_object_names {
         // Test single identifier without quotes
         assert_eq!(
-            databricks().verified_stmt(&format!("USE {}", object_name)),
-            Statement::Use(Use::Object(ObjectName(vec![Ident::new(
+            databricks().verified_stmt(&format!("USE {object_name}")),
+            Statement::Use(Use::Object(ObjectName::from(vec![Ident::new(
                 object_name.to_string()
             )])))
         );
         for &quote in &quote_styles {
             // Test single identifier with different type of quotes
             assert_eq!(
-                databricks().verified_stmt(&format!("USE {0}{1}{0}", quote, object_name)),
-                Statement::Use(Use::Object(ObjectName(vec![Ident::with_quote(
+                databricks().verified_stmt(&format!("USE {quote}{object_name}{quote}")),
+                Statement::Use(Use::Object(ObjectName::from(vec![Ident::with_quote(
                     quote,
                     object_name.to_string(),
                 )])))
@@ -224,22 +234,22 @@ fn parse_use() {
     for &quote in &quote_styles {
         // Test single identifier with keyword and different type of quotes
         assert_eq!(
-            databricks().verified_stmt(&format!("USE CATALOG {0}my_catalog{0}", quote)),
-            Statement::Use(Use::Catalog(ObjectName(vec![Ident::with_quote(
+            databricks().verified_stmt(&format!("USE CATALOG {quote}my_catalog{quote}")),
+            Statement::Use(Use::Catalog(ObjectName::from(vec![Ident::with_quote(
                 quote,
                 "my_catalog".to_string(),
             )])))
         );
         assert_eq!(
-            databricks().verified_stmt(&format!("USE DATABASE {0}my_database{0}", quote)),
-            Statement::Use(Use::Database(ObjectName(vec![Ident::with_quote(
+            databricks().verified_stmt(&format!("USE DATABASE {quote}my_database{quote}")),
+            Statement::Use(Use::Database(ObjectName::from(vec![Ident::with_quote(
                 quote,
                 "my_database".to_string(),
             )])))
         );
         assert_eq!(
-            databricks().verified_stmt(&format!("USE SCHEMA {0}my_schema{0}", quote)),
-            Statement::Use(Use::Schema(ObjectName(vec![Ident::with_quote(
+            databricks().verified_stmt(&format!("USE SCHEMA {quote}my_schema{quote}")),
+            Statement::Use(Use::Schema(ObjectName::from(vec![Ident::with_quote(
                 quote,
                 "my_schema".to_string(),
             )])))
@@ -249,15 +259,19 @@ fn parse_use() {
     // Test single identifier with keyword and no quotes
     assert_eq!(
         databricks().verified_stmt("USE CATALOG my_catalog"),
-        Statement::Use(Use::Catalog(ObjectName(vec![Ident::new("my_catalog")])))
+        Statement::Use(Use::Catalog(ObjectName::from(vec![Ident::new(
+            "my_catalog"
+        )])))
     );
     assert_eq!(
         databricks().verified_stmt("USE DATABASE my_schema"),
-        Statement::Use(Use::Database(ObjectName(vec![Ident::new("my_schema")])))
+        Statement::Use(Use::Database(ObjectName::from(vec![Ident::new(
+            "my_schema"
+        )])))
     );
     assert_eq!(
         databricks().verified_stmt("USE SCHEMA my_schema"),
-        Statement::Use(Use::Schema(ObjectName(vec![Ident::new("my_schema")])))
+        Statement::Use(Use::Schema(ObjectName::from(vec![Ident::new("my_schema")])))
     );
 
     // Test invalid syntax - missing identifier
@@ -278,8 +292,8 @@ fn parse_databricks_struct_function() {
             .projection[0],
         SelectItem::UnnamedExpr(Expr::Struct {
             values: vec![
-                Expr::Value(number("1")),
-                Expr::Value(Value::SingleQuotedString("foo".to_string()))
+                Expr::value(number("1")),
+                Expr::Value((Value::SingleQuotedString("foo".to_string())).with_empty_span())
             ],
             fields: vec![]
         })
@@ -291,16 +305,62 @@ fn parse_databricks_struct_function() {
         SelectItem::UnnamedExpr(Expr::Struct {
             values: vec![
                 Expr::Named {
-                    expr: Expr::Value(number("1")).into(),
+                    expr: Expr::value(number("1")).into(),
                     name: Ident::new("one")
                 },
                 Expr::Named {
-                    expr: Expr::Value(Value::SingleQuotedString("foo".to_string())).into(),
+                    expr: Expr::Value(
+                        (Value::SingleQuotedString("foo".to_string())).with_empty_span()
+                    )
+                    .into(),
                     name: Ident::new("foo")
                 },
-                Expr::Value(Value::Boolean(false))
+                Expr::Value((Value::Boolean(false)).with_empty_span())
             ],
             fields: vec![]
         })
     );
 }
+
+#[test]
+fn data_type_timestamp_ntz() {
+    // Literal
+    assert_eq!(
+        databricks().verified_expr("TIMESTAMP_NTZ '2025-03-29T18:52:00'"),
+        Expr::TypedString {
+            data_type: DataType::TimestampNtz,
+            value: ValueWithSpan {
+                value: Value::SingleQuotedString("2025-03-29T18:52:00".to_owned()),
+                span: Span::empty(),
+            }
+        }
+    );
+
+    // Cast
+    assert_eq!(
+        databricks().verified_expr("(created_at)::TIMESTAMP_NTZ"),
+        Expr::Cast {
+            kind: CastKind::DoubleColon,
+            expr: Box::new(Expr::Nested(Box::new(Expr::Identifier(
+                "created_at".into()
+            )))),
+            data_type: DataType::TimestampNtz,
+            format: None
+        }
+    );
+
+    // Column definition
+    match databricks().verified_stmt("CREATE TABLE foo (x TIMESTAMP_NTZ)") {
+        Statement::CreateTable(CreateTable { columns, .. }) => {
+            assert_eq!(
+                columns,
+                vec![ColumnDef {
+                    name: "x".into(),
+                    data_type: DataType::TimestampNtz,
+                    options: vec![],
+                }]
+            );
+        }
+        s => panic!("Unexpected statement: {s:?}"),
+    }
+}

tests/sqlparser_duckdb.rs

@@ -24,6 +24,7 @@ use test_utils::*;
 
 use sqlparser::ast::*;
 use sqlparser::dialect::{DuckDbDialect, GenericDialect};
+use sqlparser::parser::ParserError;
 
 fn duckdb() -> TestedDialects {
     TestedDialects::new(vec![Box::new(DuckDbDialect {})])
@@ -44,10 +45,12 @@ fn test_struct() {
             StructField {
                 field_name: Some(Ident::new("v")),
                 field_type: DataType::Varchar(None),
+                options: None,
             },
             StructField {
                 field_name: Some(Ident::new("i")),
                 field_type: DataType::Integer(None),
+                options: None,
             },
         ],
         StructBracketKind::Parentheses,
@@ -60,7 +63,6 @@ fn test_struct() {
         vec![ColumnDef {
             name: "s".into(),
             data_type: struct_type1.clone(),
-            collation: None,
             options: vec![],
         }]
     );
@@ -75,7 +77,6 @@ fn test_struct() {
                 Box::new(struct_type1),
                 None
             )),
-            collation: None,
             options: vec![],
         }]
     );
@@ -86,6 +87,7 @@ fn test_struct() {
             StructField {
                 field_name: Some(Ident::new("v")),
                 field_type: DataType::Varchar(None),
+                options: None,
             },
             StructField {
                 field_name: Some(Ident::new("s")),
@@ -94,14 +96,17 @@ fn test_struct() {
                         StructField {
                             field_name: Some(Ident::new("a1")),
                             field_type: DataType::Integer(None),
+                            options: None,
                         },
                         StructField {
                             field_name: Some(Ident::new("a2")),
                             field_type: DataType::Varchar(None),
+                            options: None,
                         },
                     ],
                     StructBracketKind::Parentheses,
                 ),
+                options: None,
             },
         ],
         StructBracketKind::Parentheses,
@@ -120,7 +125,6 @@ fn test_struct() {
                 Box::new(struct_type2),
                 None
             )),
-            collation: None,
             options: vec![],
         }]
     );
@@ -160,7 +164,7 @@ fn test_select_wildcard_with_exclude() {
     let select =
         duckdb().verified_only_select("SELECT name.* EXCLUDE department_id FROM employee_table");
     let expected = SelectItem::QualifiedWildcard(
-        ObjectName(vec![Ident::new("name")]),
+        SelectItemQualifiedWildcardKind::ObjectName(ObjectName::from(vec![Ident::new("name")])),
         WildcardAdditionalOptions {
             opt_exclude: Some(ExcludeSelectItem::Single(Ident::new("department_id"))),
             ..Default::default()
@@ -191,7 +195,7 @@ fn test_create_macro() {
     let expected = Statement::CreateMacro {
         or_replace: false,
         temporary: false,
-        name: ObjectName(vec![Ident::new("schema"), Ident::new("add")]),
+        name: ObjectName::from(vec![Ident::new("schema"), Ident::new("add")]),
         args: Some(vec![MacroArg::new("a"), MacroArg::new("b")]),
         definition: MacroDefinition::Expr(Expr::BinaryOp {
             left: Box::new(Expr::Identifier(Ident::new("a"))),
@@ -208,12 +212,12 @@ fn test_create_macro_default_args() {
     let expected = Statement::CreateMacro {
         or_replace: false,
         temporary: false,
-        name: ObjectName(vec![Ident::new("add_default")]),
+        name: ObjectName::from(vec![Ident::new("add_default")]),
         args: Some(vec![
             MacroArg::new("a"),
             MacroArg {
                 name: Ident::new("b"),
-                default_expr: Some(Expr::Value(number("5"))),
+                default_expr: Some(Expr::value(number("5"))),
             },
         ]),
         definition: MacroDefinition::Expr(Expr::BinaryOp {
@@ -236,7 +240,7 @@ fn test_create_table_macro() {
     let expected = Statement::CreateMacro {
         or_replace: true,
         temporary: true,
-        name: ObjectName(vec![Ident::new("dynamic_table")]),
+        name: ObjectName::from(vec![Ident::new("dynamic_table")]),
         args: Some(vec![
             MacroArg::new("col1_value"),
             MacroArg::new("col2_value"),
@@ -268,7 +272,7 @@ fn test_select_union_by_name() {
                 top_before_distinct: false,
                 into: None,
                 from: vec![TableWithJoins {
-                    relation: table_from_name(ObjectName(vec![Ident {
+                    relation: table_from_name(ObjectName::from(vec![Ident {
                         value: "capitals".to_string(),
                         quote_style: None,
                         span: Span::empty(),
@@ -288,6 +292,7 @@ fn test_select_union_by_name() {
                 qualify: None,
                 value_table_mode: None,
                 connect_by: None,
+                flavor: SelectFlavor::Standard,
             }))),
             right: Box::<SetExpr>::new(SetExpr::Select(Box::new(Select {
                 select_token: AttachedToken::empty(),
@@ -297,7 +302,7 @@ fn test_select_union_by_name() {
                 top_before_distinct: false,
                 into: None,
                 from: vec![TableWithJoins {
-                    relation: table_from_name(ObjectName(vec![Ident {
+                    relation: table_from_name(ObjectName::from(vec![Ident {
                         value: "weather".to_string(),
                         quote_style: None,
                         span: Span::empty(),
@@ -317,6 +322,7 @@ fn test_select_union_by_name() {
                 qualify: None,
                 value_table_mode: None,
                 connect_by: None,
+                flavor: SelectFlavor::Standard,
             }))),
         });
         assert_eq!(ast.body, expected);
@@ -353,6 +359,32 @@ fn test_duckdb_load_extension() {
     );
 }
 
+#[test]
+fn test_duckdb_specific_int_types() {
+    let duckdb_dtypes = vec![
+        ("UTINYINT", DataType::UTinyInt),
+        ("USMALLINT", DataType::USmallInt),
+        ("UBIGINT", DataType::UBigInt),
+        ("UHUGEINT", DataType::UHugeInt),
+        ("HUGEINT", DataType::HugeInt),
+    ];
+    for (dtype_string, data_type) in duckdb_dtypes {
+        let sql = format!("SELECT 123::{dtype_string}");
+        let select = duckdb().verified_only_select(&sql);
+        assert_eq!(
+            &Expr::Cast {
+                kind: CastKind::DoubleColon,
+                expr: Box::new(Expr::Value(
+                    Value::Number("123".parse().unwrap(), false).with_empty_span()
+                )),
+                data_type: data_type.clone(),
+                format: None,
+            },
+            expr_from_projection(&select.projection[0])
+        );
+    }
+}
+
 #[test]
 fn test_duckdb_struct_literal() {
     //struct literal syntax https://duckdb.org/docs/sql/data_types/struct#creating-structs
@@ -364,15 +396,15 @@ fn test_duckdb_struct_literal() {
         &Expr::Dictionary(vec![
             DictionaryField {
                 key: Ident::with_quote('\'', "a"),
-                value: Box::new(Expr::Value(number("1"))),
+                value: Box::new(Expr::value(number("1"))),
             },
             DictionaryField {
                 key: Ident::with_quote('\'', "b"),
-                value: Box::new(Expr::Value(number("2"))),
+                value: Box::new(Expr::value(number("2"))),
             },
             DictionaryField {
                 key: Ident::with_quote('\'', "c"),
-                value: Box::new(Expr::Value(number("3"))),
+                value: Box::new(Expr::value(number("3"))),
             },
         ],),
         expr_from_projection(&select.projection[0])
@@ -382,7 +414,9 @@ fn test_duckdb_struct_literal() {
         &Expr::Array(Array {
             elem: vec![Expr::Dictionary(vec![DictionaryField {
                 key: Ident::with_quote('\'', "a"),
-                value: Box::new(Expr::Value(Value::SingleQuotedString("abc".to_string()))),
+                value: Box::new(Expr::Value(
+                    (Value::SingleQuotedString("abc".to_string())).with_empty_span()
+                )),
             },],)],
             named: false
         }),
@@ -392,7 +426,7 @@ fn test_duckdb_struct_literal() {
         &Expr::Dictionary(vec![
             DictionaryField {
                 key: Ident::with_quote('\'', "a"),
-                value: Box::new(Expr::Value(number("1"))),
+                value: Box::new(Expr::value(number("1"))),
             },
             DictionaryField {
                 key: Ident::with_quote('\'', "b"),
@@ -411,11 +445,14 @@ fn test_duckdb_struct_literal() {
         &Expr::Dictionary(vec![
             DictionaryField {
                 key: Ident::with_quote('\'', "a"),
-                value: Expr::Value(number("1")).into(),
+                value: Expr::value(number("1")).into(),
             },
             DictionaryField {
                 key: Ident::with_quote('\'', "b"),
-                value: Expr::Value(Value::SingleQuotedString("abc".to_string())).into(),
+                value: Expr::Value(
+                    (Value::SingleQuotedString("abc".to_string())).with_empty_span()
+                )
+                .into(),
             },
         ],),
         expr_from_projection(&select.projection[3])
@@ -432,7 +469,7 @@ fn test_duckdb_struct_literal() {
             key: Ident::with_quote('\'', "a"),
             value: Expr::Dictionary(vec![DictionaryField {
                 key: Ident::with_quote('\'', "aa"),
-                value: Expr::Value(number("1")).into(),
+                value: Expr::value(number("1")).into(),
             }],)
             .into(),
         }],),
@@ -587,7 +624,7 @@ fn test_duckdb_named_argument_function_with_assignment_operator() {
     let select = duckdb_and_generic().verified_only_select(sql);
     assert_eq!(
         &Expr::Function(Function {
-            name: ObjectName(vec![Ident::new("FUN")]),
+            name: ObjectName::from(vec![Ident::new("FUN")]),
             uses_odbc_syntax: false,
             parameters: FunctionArguments::None,
             args: FunctionArguments::List(FunctionArgumentList {
@@ -595,16 +632,16 @@ fn test_duckdb_named_argument_function_with_assignment_operator() {
                 args: vec![
                     FunctionArg::Named {
                         name: Ident::new("a"),
-                        arg: FunctionArgExpr::Expr(Expr::Value(Value::SingleQuotedString(
-                            "1".to_owned()
-                        ))),
+                        arg: FunctionArgExpr::Expr(Expr::Value(
+                            (Value::SingleQuotedString("1".to_owned())).with_empty_span()
+                        )),
                         operator: FunctionArgOperator::Assignment
                     },
                     FunctionArg::Named {
                         name: Ident::new("b"),
-                        arg: FunctionArgExpr::Expr(Expr::Value(Value::SingleQuotedString(
-                            "2".to_owned()
-                        ))),
+                        arg: FunctionArgExpr::Expr(Expr::Value(
+                            (Value::SingleQuotedString("2".to_owned())).with_empty_span()
+                        )),
                         operator: FunctionArgOperator::Assignment
                     },
                 ],
@@ -633,14 +670,14 @@ fn test_array_index() {
         &Expr::CompoundFieldAccess {
             root: Box::new(Expr::Array(Array {
                 elem: vec![
-                    Expr::Value(Value::SingleQuotedString("a".to_owned())),
-                    Expr::Value(Value::SingleQuotedString("b".to_owned())),
-                    Expr::Value(Value::SingleQuotedString("c".to_owned()))
+                    Expr::Value((Value::SingleQuotedString("a".to_owned())).with_empty_span()),
+                    Expr::Value((Value::SingleQuotedString("b".to_owned())).with_empty_span()),
+                    Expr::Value((Value::SingleQuotedString("c".to_owned())).with_empty_span())
                 ],
                 named: false
             })),
             access_chain: vec![AccessExpr::Subscript(Subscript::Index {
-                index: Expr::Value(number("3"))
+                index: Expr::value(number("3"))
             })]
         },
         expr
@@ -660,7 +697,8 @@ fn test_duckdb_union_datatype() {
             if_not_exists: Default::default(),
             transient: Default::default(),
             volatile: Default::default(),
-            name: ObjectName(vec!["tbl1".into()]),
+            iceberg: Default::default(),
+            name: ObjectName::from(vec!["tbl1".into()]),
             columns: vec![
                 ColumnDef {
                     name: "one".into(),
@@ -668,7 +706,6 @@ fn test_duckdb_union_datatype() {
                         field_name: "a".into(),
                         field_type: DataType::Int(None)
                     }]),
-                    collation: Default::default(),
                     options: Default::default()
                 },
                 ColumnDef {
@@ -683,7 +720,6 @@ fn test_duckdb_union_datatype() {
                             field_type: DataType::Int(None)
                         }
                     ]),
-                    collation: Default::default(),
                     options: Default::default()
                 },
                 ColumnDef {
@@ -695,7 +731,6 @@ fn test_duckdb_union_datatype() {
                             field_type: DataType::Int(None)
                         }])
                     }]),
-                    collation: Default::default(),
                     options: Default::default()
                 }
             ],
@@ -707,19 +742,13 @@ fn test_duckdb_union_datatype() {
                 storage: Default::default(),
                 location: Default::default()
             }),
-            table_properties: Default::default(),
-            with_options: Default::default(),
             file_format: Default::default(),
             location: Default::default(),
             query: Default::default(),
             without_rowid: Default::default(),
             like: Default::default(),
             clone: Default::default(),
-            engine: Default::default(),
             comment: Default::default(),
-            auto_increment_offset: Default::default(),
-            default_charset: Default::default(),
-            collation: Default::default(),
             on_commit: Default::default(),
             on_cluster: Default::default(),
             primary_key: Default::default(),
@@ -727,7 +756,7 @@ fn test_duckdb_union_datatype() {
             partition_by: Default::default(),
             cluster_by: Default::default(),
             clustered_by: Default::default(),
-            options: Default::default(),
+            inherits: Default::default(),
             strict: Default::default(),
             copy_grants: Default::default(),
             enable_schema_evolution: Default::default(),
@@ -737,7 +766,13 @@ fn test_duckdb_union_datatype() {
             default_ddl_collation: Default::default(),
             with_aggregation_policy: Default::default(),
             with_row_access_policy: Default::default(),
-            with_tags: Default::default()
+            with_tags: Default::default(),
+            base_location: Default::default(),
+            external_volume: Default::default(),
+            catalog: Default::default(),
+            catalog_sync: Default::default(),
+            storage_serialization_policy: Default::default(),
+            table_options: CreateTableOptions::None
         }),
         stmt
     );
@@ -758,16 +793,16 @@ fn parse_use() {
     for object_name in &valid_object_names {
         // Test single identifier without quotes
         assert_eq!(
-            duckdb().verified_stmt(&format!("USE {}", object_name)),
-            Statement::Use(Use::Object(ObjectName(vec![Ident::new(
+            duckdb().verified_stmt(&format!("USE {object_name}")),
+            Statement::Use(Use::Object(ObjectName::from(vec![Ident::new(
                 object_name.to_string()
             )])))
         );
         for &quote in &quote_styles {
             // Test single identifier with different type of quotes
             assert_eq!(
-                duckdb().verified_stmt(&format!("USE {0}{1}{0}", quote, object_name)),
-                Statement::Use(Use::Object(ObjectName(vec![Ident::with_quote(
+                duckdb().verified_stmt(&format!("USE {quote}{object_name}{quote}")),
+                Statement::Use(Use::Object(ObjectName::from(vec![Ident::with_quote(
                     quote,
                     object_name.to_string(),
                 )])))
@@ -778,8 +813,10 @@ fn parse_use() {
     for &quote in &quote_styles {
         // Test double identifier with different type of quotes
         assert_eq!(
-            duckdb().verified_stmt(&format!("USE {0}CATALOG{0}.{0}my_schema{0}", quote)),
-            Statement::Use(Use::Object(ObjectName(vec![
+            duckdb().verified_stmt(&format!(
+                "USE {quote}CATALOG{quote}.{quote}my_schema{quote}"
+            )),
+            Statement::Use(Use::Object(ObjectName::from(vec![
                 Ident::with_quote(quote, "CATALOG"),
                 Ident::with_quote(quote, "my_schema")
             ])))
@@ -788,9 +825,38 @@ fn parse_use() {
     // Test double identifier without quotes
     assert_eq!(
         duckdb().verified_stmt("USE mydb.my_schema"),
-        Statement::Use(Use::Object(ObjectName(vec![
+        Statement::Use(Use::Object(ObjectName::from(vec![
             Ident::new("mydb"),
             Ident::new("my_schema")
         ])))
     );
 }
+
+#[test]
+fn test_duckdb_trim() {
+    let real_sql = r#"SELECT customer_id, TRIM(item_price_id, '"', "a") AS item_price_id FROM models_staging.subscriptions"#;
+    assert_eq!(duckdb().verified_stmt(real_sql).to_string(), real_sql);
+
+    let sql_only_select = "SELECT TRIM('xyz', 'a')";
+    let select = duckdb().verified_only_select(sql_only_select);
+    assert_eq!(
+        &Expr::Trim {
+            expr: Box::new(Expr::Value(
+                Value::SingleQuotedString("xyz".to_owned()).with_empty_span()
+            )),
+            trim_where: None,
+            trim_what: None,
+            trim_characters: Some(vec![Expr::Value(
+                Value::SingleQuotedString("a".to_owned()).with_empty_span()
+            )]),
+        },
+        expr_from_projection(only(&select.projection))
+    );
+
+    // missing comma separation
+    let error_sql = "SELECT TRIM('xyz' 'a')";
+    assert_eq!(
+        ParserError::ParserError("Expected: ), found: 'a'".to_owned()),
+        duckdb().parse_sql_statements(error_sql).unwrap_err()
+    );
+}

tests/sqlparser_hive.rs

@@ -22,11 +22,10 @@
 
 use sqlparser::ast::{
     ClusteredBy, CommentDef, CreateFunction, CreateFunctionBody, CreateFunctionUsing, CreateTable,
-    Expr, Function, FunctionArgumentList, FunctionArguments, Ident, ObjectName,
-    OneOrManyWithParens, OrderByExpr, SelectItem, Statement, TableFactor, UnaryOperator, Use,
-    Value,
+    Expr, Function, FunctionArgumentList, FunctionArguments, Ident, ObjectName, OrderByExpr,
+    OrderByOptions, SelectItem, Set, Statement, TableFactor, UnaryOperator, Use, Value,
 };
-use sqlparser::dialect::{GenericDialect, HiveDialect, MsSqlDialect};
+use sqlparser::dialect::{AnsiDialect, GenericDialect, HiveDialect};
 use sqlparser::parser::ParserError;
 use sqlparser::test_utils::*;
 
@@ -92,7 +91,7 @@ fn parse_msck() {
 }
 
 #[test]
-fn parse_set() {
+fn parse_set_hivevar() {
     let set = "SET HIVEVAR:name = a, b, c_d";
     hive().verified_stmt(set);
 }
@@ -134,9 +133,7 @@ fn create_table_with_comment() {
         Statement::CreateTable(CreateTable { comment, .. }) => {
             assert_eq!(
                 comment,
-                Some(CommentDef::AfterColumnDefsWithoutEq(
-                    "table comment".to_string()
-                ))
+                Some(CommentDef::WithoutEq("table comment".to_string()))
             )
         }
         _ => unreachable!(),
@@ -171,14 +168,18 @@ fn create_table_with_clustered_by() {
                     sorted_by: Some(vec![
                         OrderByExpr {
                             expr: Expr::Identifier(Ident::new("a")),
-                            asc: Some(true),
-                            nulls_first: None,
+                            options: OrderByOptions {
+                                asc: Some(true),
+                                nulls_first: None,
+                            },
                             with_fill: None,
                         },
                         OrderByExpr {
                             expr: Expr::Identifier(Ident::new("b")),
-                            asc: Some(false),
-                            nulls_first: None,
+                            options: OrderByOptions {
+                                asc: Some(false),
+                                nulls_first: None,
+                            },
                             with_fill: None,
                         },
                     ]),
@@ -340,6 +341,9 @@ fn lateral_view() {
 fn sort_by() {
     let sort_by = "SELECT * FROM db.table SORT BY a";
     hive().verified_stmt(sort_by);
+
+    let sort_by_with_direction = "SELECT * FROM db.table SORT BY a, b DESC";
+    hive().verified_stmt(sort_by_with_direction);
 }
 
 #[test]
@@ -365,20 +369,20 @@ fn from_cte() {
 fn set_statement_with_minus() {
     assert_eq!(
         hive().verified_stmt("SET hive.tez.java.opts = -Xmx4g"),
-        Statement::SetVariable {
-            local: false,
+        Statement::Set(Set::SingleAssignment {
+            scope: None,
             hivevar: false,
-            variables: OneOrManyWithParens::One(ObjectName(vec![
+            variable: ObjectName::from(vec![
                 Ident::new("hive"),
                 Ident::new("tez"),
                 Ident::new("java"),
                 Ident::new("opts")
-            ])),
-            value: vec![Expr::UnaryOp {
+            ]),
+            values: vec![Expr::UnaryOp {
                 op: UnaryOperator::Minus,
                 expr: Box::new(Expr::Identifier(Ident::new("Xmx4g")))
             }],
-        }
+        })
     );
 
     assert_eq!(
@@ -405,7 +409,8 @@ fn parse_create_function() {
             assert_eq!(
                 function_body,
                 Some(CreateFunctionBody::AsBeforeOptions(Expr::Value(
-                    Value::SingleQuotedString("org.random.class.Name".to_string())
+                    (Value::SingleQuotedString("org.random.class.Name".to_string()))
+                        .with_empty_span()
                 )))
             );
             assert_eq!(
@@ -419,7 +424,7 @@ fn parse_create_function() {
     }
 
     // Test error in dialect that doesn't support parsing CREATE FUNCTION
-    let unsupported_dialects = TestedDialects::new(vec![Box::new(MsSqlDialect {})]);
+    let unsupported_dialects = TestedDialects::new(vec![Box::new(AnsiDialect {})]);
 
     assert_eq!(
         unsupported_dialects.parse_sql_statements(sql).unwrap_err(),
@@ -460,8 +465,12 @@ fn parse_delimited_identifiers() {
             partitions: _,
             json_path: _,
             sample: _,
+            index_hints: _,
         } => {
-            assert_eq!(vec![Ident::with_quote('"', "a table")], name.0);
+            assert_eq!(
+                ObjectName::from(vec![Ident::with_quote('"', "a table")]),
+                name
+            );
             assert_eq!(Ident::with_quote('"', "alias"), alias.unwrap().name);
             assert!(args.is_none());
             assert!(with_hints.is_empty());
@@ -480,7 +489,7 @@ fn parse_delimited_identifiers() {
     );
     assert_eq!(
         &Expr::Function(Function {
-            name: ObjectName(vec![Ident::with_quote('"', "myfun")]),
+            name: ObjectName::from(vec![Ident::with_quote('"', "myfun")]),
             uses_odbc_syntax: false,
             parameters: FunctionArguments::None,
             args: FunctionArguments::List(FunctionArgumentList {
@@ -515,16 +524,16 @@ fn parse_use() {
     for object_name in &valid_object_names {
         // Test single identifier without quotes
         assert_eq!(
-            hive().verified_stmt(&format!("USE {}", object_name)),
-            Statement::Use(Use::Object(ObjectName(vec![Ident::new(
+            hive().verified_stmt(&format!("USE {object_name}")),
+            Statement::Use(Use::Object(ObjectName::from(vec![Ident::new(
                 object_name.to_string()
             )])))
         );
         for &quote in &quote_styles {
             // Test single identifier with different type of quotes
             assert_eq!(
-                hive().verified_stmt(&format!("USE {}{}{}", quote, object_name, quote)),
-                Statement::Use(Use::Object(ObjectName(vec![Ident::with_quote(
+                hive().verified_stmt(&format!("USE {quote}{object_name}{quote}")),
+                Statement::Use(Use::Object(ObjectName::from(vec![Ident::with_quote(
                     quote,
                     object_name.to_string(),
                 )])))

tests/sqlparser_redshift.rs

@@ -39,7 +39,7 @@ fn test_square_brackets_over_db_schema_table_name() {
     assert_eq!(
         select.from[0],
         TableWithJoins {
-            relation: table_from_name(ObjectName(vec![
+            relation: table_from_name(ObjectName::from(vec![
                 Ident {
                     value: "test_schema".to_string(),
                     quote_style: Some('['),
@@ -81,7 +81,7 @@ fn test_double_quotes_over_db_schema_table_name() {
     assert_eq!(
         select.from[0],
         TableWithJoins {
-            relation: table_from_name(ObjectName(vec![
+            relation: table_from_name(ObjectName::from(vec![
                 Ident {
                     value: "test_schema".to_string(),
                     quote_style: Some('"'),
@@ -114,7 +114,10 @@ fn parse_delimited_identifiers() {
             version,
             ..
         } => {
-            assert_eq!(vec![Ident::with_quote('"', "a table")], name.0);
+            assert_eq!(
+                ObjectName::from(vec![Ident::with_quote('"', "a table")]),
+                name
+            );
             assert_eq!(Ident::with_quote('"', "alias"), alias.unwrap().name);
             assert!(args.is_none());
             assert!(with_hints.is_empty());
@@ -133,7 +136,7 @@ fn parse_delimited_identifiers() {
     );
     assert_eq!(
         &Expr::Function(Function {
-            name: ObjectName(vec![Ident::with_quote('"', "myfun")]),
+            name: ObjectName::from(vec![Ident::with_quote('"', "myfun")]),
             uses_odbc_syntax: false,
             parameters: FunctionArguments::None,
             args: FunctionArguments::List(FunctionArgumentList {
@@ -205,7 +208,7 @@ fn test_redshift_json_path() {
             path: JsonPath {
                 path: vec![
                     JsonPathElem::Bracket {
-                        key: Expr::Value(number("0"))
+                        key: Expr::value(number("0"))
                     },
                     JsonPathElem::Dot {
                         key: "o_orderkey".to_string(),
@@ -228,10 +231,12 @@ fn test_redshift_json_path() {
             path: JsonPath {
                 path: vec![
                     JsonPathElem::Bracket {
-                        key: Expr::Value(number("0"))
+                        key: Expr::value(number("0"))
                     },
                     JsonPathElem::Bracket {
-                        key: Expr::Value(Value::SingleQuotedString("id".to_owned()))
+                        key: Expr::Value(
+                            (Value::SingleQuotedString("id".to_owned())).with_empty_span()
+                        )
                     }
                 ]
             }
@@ -252,10 +257,12 @@ fn test_redshift_json_path() {
             path: JsonPath {
                 path: vec![
                     JsonPathElem::Bracket {
-                        key: Expr::Value(number("0"))
+                        key: Expr::value(number("0"))
                     },
                     JsonPathElem::Bracket {
-                        key: Expr::Value(Value::SingleQuotedString("id".to_owned()))
+                        key: Expr::Value(
+                            (Value::SingleQuotedString("id".to_owned())).with_empty_span()
+                        )
                     }
                 ]
             }
@@ -276,7 +283,7 @@ fn test_redshift_json_path() {
             path: JsonPath {
                 path: vec![
                     JsonPathElem::Bracket {
-                        key: Expr::Value(number("0"))
+                        key: Expr::value(number("0"))
                     },
                     JsonPathElem::Dot {
                         key: "id".to_string(),
@@ -297,13 +304,13 @@ fn test_parse_json_path_from() {
         TableFactor::Table {
             name, json_path, ..
         } => {
-            assert_eq!(name, &ObjectName(vec![Ident::new("src")]));
+            assert_eq!(name, &ObjectName::from(vec![Ident::new("src")]));
             assert_eq!(
                 json_path,
                 &Some(JsonPath {
                     path: vec![
                         JsonPathElem::Bracket {
-                            key: Expr::Value(number("0"))
+                            key: Expr::value(number("0"))
                         },
                         JsonPathElem::Dot {
                             key: "a".to_string(),
@@ -321,20 +328,22 @@ fn test_parse_json_path_from() {
         TableFactor::Table {
             name, json_path, ..
         } => {
-            assert_eq!(name, &ObjectName(vec![Ident::new("src")]));
+            assert_eq!(name, &ObjectName::from(vec![Ident::new("src")]));
             assert_eq!(
                 json_path,
                 &Some(JsonPath {
                     path: vec![
                         JsonPathElem::Bracket {
-                            key: Expr::Value(number("0"))
+                            key: Expr::value(number("0"))
                         },
                         JsonPathElem::Dot {
                             key: "a".to_string(),
                             quoted: false
                         },
                         JsonPathElem::Bracket {
-                            key: Expr::Value(Value::Number("1".parse().unwrap(), false))
+                            key: Expr::Value(
+                                (Value::Number("1".parse().unwrap(), false)).with_empty_span()
+                            )
                         },
                         JsonPathElem::Dot {
                             key: "b".to_string(),
@@ -354,7 +363,7 @@ fn test_parse_json_path_from() {
         } => {
             assert_eq!(
                 name,
-                &ObjectName(vec![Ident::new("src"), Ident::new("a"), Ident::new("b")])
+                &ObjectName::from(vec![Ident::new("src"), Ident::new("a"), Ident::new("b")])
             );
             assert_eq!(json_path, &None);
         }
@@ -382,3 +391,19 @@ fn test_parse_nested_quoted_identifier() {
         .parse_sql_statements(r#"SELECT 1 AS ["1]"#)
         .is_err());
 }
+
+#[test]
+fn parse_extract_single_quotes() {
+    let sql = "SELECT EXTRACT('month' FROM my_timestamp) FROM my_table";
+    redshift().verified_stmt(sql);
+}
+
+#[test]
+fn parse_string_literal_backslash_escape() {
+    redshift().one_statement_parses_to(r#"SELECT 'l\'auto'"#, "SELECT 'l''auto'");
+}
+
+#[test]
+fn parse_utf8_multibyte_idents() {
+    redshift().verified_stmt("SELECT 🚀.city AS 🎸 FROM customers AS 🚀");
+}

tests/sqlparser_sqlite.rs

@@ -214,7 +214,6 @@ fn parse_create_table_auto_increment() {
                 vec![ColumnDef {
                     name: "bar".into(),
                     data_type: DataType::Int(None),
-                    collation: None,
                     options: vec![
                         ColumnOptionDef {
                             name: None,
@@ -243,7 +242,6 @@ fn parse_create_table_primary_key_asc_desc() {
     let expected_column_def = |kind| ColumnDef {
         name: "bar".into(),
         data_type: DataType::Int(None),
-        collation: None,
         options: vec![
             ColumnOptionDef {
                 name: None,
@@ -286,13 +284,11 @@ fn parse_create_sqlite_quote() {
                     ColumnDef {
                         name: Ident::with_quote('"', "KEY"),
                         data_type: DataType::Int(None),
-                        collation: None,
                         options: vec![],
                     },
                     ColumnDef {
                         name: Ident::with_quote('[', "INDEX"),
                         data_type: DataType::Int(None),
-                        collation: None,
                         options: vec![],
                     },
                 ],
@@ -328,7 +324,7 @@ fn parse_create_table_on_conflict_col() {
         Keyword::IGNORE,
         Keyword::REPLACE,
     ] {
-        let sql = format!("CREATE TABLE t1 (a INT, b INT ON CONFLICT {:?})", keyword);
+        let sql = format!("CREATE TABLE t1 (a INT, b INT ON CONFLICT {keyword:?})");
         match sqlite_and_generic().verified_stmt(&sql) {
             Statement::CreateTable(CreateTable { columns, .. }) => {
                 assert_eq!(
@@ -373,7 +369,9 @@ fn test_placeholder() {
     let ast = sqlite().verified_only_select(sql);
     assert_eq!(
         ast.projection[0],
-        UnnamedExpr(Expr::Value(Value::Placeholder("@xxx".into()))),
+        UnnamedExpr(Expr::Value(
+            (Value::Placeholder("@xxx".into())).with_empty_span()
+        )),
     );
 }
 
@@ -412,13 +410,13 @@ fn parse_window_function_with_filter() {
         "count",
         "user_defined_function",
     ] {
-        let sql = format!("SELECT {}(x) FILTER (WHERE y) OVER () FROM t", func_name);
+        let sql = format!("SELECT {func_name}(x) FILTER (WHERE y) OVER () FROM t");
         let select = sqlite().verified_only_select(&sql);
         assert_eq!(select.to_string(), sql);
         assert_eq!(
             select.projection,
             vec![SelectItem::UnnamedExpr(Expr::Function(Function {
-                name: ObjectName(vec![Ident::new(func_name)]),
+                name: ObjectName::from(vec![Ident::new(func_name)]),
                 uses_odbc_syntax: false,
                 parameters: FunctionArguments::None,
                 args: FunctionArguments::List(FunctionArgumentList {
@@ -446,11 +444,15 @@ fn parse_window_function_with_filter() {
 fn parse_attach_database() {
     let sql = "ATTACH DATABASE 'test.db' AS test";
     let verified_stmt = sqlite().verified_stmt(sql);
-    assert_eq!(sql, format!("{}", verified_stmt));
+    assert_eq!(sql, format!("{verified_stmt}"));
     match verified_stmt {
         Statement::AttachDatabase {
             schema_name,
-            database_file_name: Expr::Value(Value::SingleQuotedString(literal_name)),
+            database_file_name:
+                Expr::Value(ValueWithSpan {
+                    value: Value::SingleQuotedString(literal_name),
+                    span: _,
+                }),
             database: true,
         } => {
             assert_eq!(schema_name.value, "test");
@@ -469,17 +471,17 @@ fn parse_update_tuple_row_values() {
             or: None,
             assignments: vec![Assignment {
                 target: AssignmentTarget::Tuple(vec![
-                    ObjectName(vec![Ident::new("a"),]),
-                    ObjectName(vec![Ident::new("b"),]),
+                    ObjectName::from(vec![Ident::new("a"),]),
+                    ObjectName::from(vec![Ident::new("b"),]),
                 ]),
                 value: Expr::Tuple(vec![
-                    Expr::Value(Value::Number("1".parse().unwrap(), false)),
-                    Expr::Value(Value::Number("2".parse().unwrap(), false))
+                    Expr::Value((Value::Number("1".parse().unwrap(), false)).with_empty_span()),
+                    Expr::Value((Value::Number("2".parse().unwrap(), false)).with_empty_span())
                 ])
             }],
             selection: None,
             table: TableWithJoins {
-                relation: table_from_name(ObjectName(vec![Ident::new("x")])),
+                relation: table_from_name(ObjectName::from(vec![Ident::new("x")])),
                 joins: vec![],
             },
             from: None,
@@ -522,23 +524,6 @@ fn parse_start_transaction_with_modifier() {
     sqlite_and_generic().verified_stmt("BEGIN DEFERRED");
     sqlite_and_generic().verified_stmt("BEGIN IMMEDIATE");
     sqlite_and_generic().verified_stmt("BEGIN EXCLUSIVE");
-
-    let unsupported_dialects = all_dialects_except(|d| d.supports_start_transaction_modifier());
-    let res = unsupported_dialects.parse_sql_statements("BEGIN DEFERRED");
-    assert_eq!(
-        ParserError::ParserError("Expected: end of statement, found: DEFERRED".to_string()),
-        res.unwrap_err(),
-    );
-    let res = unsupported_dialects.parse_sql_statements("BEGIN IMMEDIATE");
-    assert_eq!(
-        ParserError::ParserError("Expected: end of statement, found: IMMEDIATE".to_string()),
-        res.unwrap_err(),
-    );
-    let res = unsupported_dialects.parse_sql_statements("BEGIN EXCLUSIVE");
-    assert_eq!(
-        ParserError::ParserError("Expected: end of statement, found: EXCLUSIVE".to_string()),
-        res.unwrap_err(),
-    );
 }
 
 #[test]
@@ -551,7 +536,12 @@ fn test_dollar_identifier_as_placeholder() {
         Expr::BinaryOp { op, left, right } => {
             assert_eq!(op, BinaryOperator::Eq);
             assert_eq!(left, Box::new(Expr::Identifier(Ident::new("id"))));
-            assert_eq!(right, Box::new(Expr::Value(Placeholder("$id".to_string()))));
+            assert_eq!(
+                right,
+                Box::new(Expr::Value(
+                    (Placeholder("$id".to_string())).with_empty_span()
+                ))
+            );
         }
         _ => unreachable!(),
     }
@@ -561,12 +551,47 @@ fn test_dollar_identifier_as_placeholder() {
         Expr::BinaryOp { op, left, right } => {
             assert_eq!(op, BinaryOperator::Eq);
             assert_eq!(left, Box::new(Expr::Identifier(Ident::new("id"))));
-            assert_eq!(right, Box::new(Expr::Value(Placeholder("$$".to_string()))));
+            assert_eq!(
+                right,
+                Box::new(Expr::Value(
+                    (Placeholder("$$".to_string())).with_empty_span()
+                ))
+            );
         }
         _ => unreachable!(),
     }
 }
 
+#[test]
+fn test_match_operator() {
+    assert_eq!(
+        sqlite().verified_expr("col MATCH 'pattern'"),
+        Expr::BinaryOp {
+            op: BinaryOperator::Match,
+            left: Box::new(Expr::Identifier(Ident::new("col"))),
+            right: Box::new(Expr::Value(
+                (Value::SingleQuotedString("pattern".to_string())).with_empty_span()
+            ))
+        }
+    );
+    sqlite().verified_only_select("SELECT * FROM email WHERE email MATCH 'fts5'");
+}
+
+#[test]
+fn test_regexp_operator() {
+    assert_eq!(
+        sqlite().verified_expr("col REGEXP 'pattern'"),
+        Expr::BinaryOp {
+            op: BinaryOperator::Regexp,
+            left: Box::new(Expr::Identifier(Ident::new("col"))),
+            right: Box::new(Expr::Value(
+                (Value::SingleQuotedString("pattern".to_string())).with_empty_span()
+            ))
+        }
+    );
+    sqlite().verified_only_select(r#"SELECT count(*) FROM messages WHERE msg_text REGEXP '\d+'"#);
+}
+
 fn sqlite() -> TestedDialects {
     TestedDialects::new(vec![Box::new(SQLiteDialect {})])
 }