mirror of
https://github.com/apache/datafusion-sqlparser-rs.git
synced 2025-07-10 02:14:58 +00:00
Compare commits
No commits in common. "main" and "v0.52.0" have entirely different histories.
72 changed files with 7230 additions and 35074 deletions
39
.github/workflows/license.yml
vendored
39
.github/workflows/license.yml
vendored
|
|
@ -1,39 +0,0 @@
|
|||
# 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 .
|
||||
20
.github/workflows/rust.yml
vendored
20
.github/workflows/rust.yml
vendored
|
|
@ -19,9 +19,6 @@ name: Rust
|
|||
|
||||
on: [push, pull_request]
|
||||
|
||||
permissions:
|
||||
contents: read
|
||||
|
||||
jobs:
|
||||
|
||||
codestyle:
|
||||
|
|
@ -30,7 +27,7 @@ jobs:
|
|||
- uses: actions/checkout@v4
|
||||
- name: Setup Rust Toolchain
|
||||
uses: ./.github/actions/setup-builder
|
||||
- run: cargo fmt --all -- --check
|
||||
- run: cargo fmt -- --check
|
||||
|
||||
lint:
|
||||
runs-on: ubuntu-latest
|
||||
|
|
@ -40,14 +37,6 @@ jobs:
|
|||
uses: ./.github/actions/setup-builder
|
||||
- run: cargo clippy --all-targets --all-features -- -D warnings
|
||||
|
||||
benchmark-lint:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- name: Setup Rust Toolchain
|
||||
uses: ./.github/actions/setup-builder
|
||||
- run: cd sqlparser_bench && cargo clippy --all-targets --all-features -- -D warnings
|
||||
|
||||
compile:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
|
|
@ -88,8 +77,11 @@ jobs:
|
|||
uses: ./.github/actions/setup-builder
|
||||
with:
|
||||
rust-version: ${{ matrix.rust }}
|
||||
- uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
|
||||
- name: Install Tarpaulin
|
||||
run: cargo install cargo-tarpaulin
|
||||
uses: actions-rs/install@v0.1
|
||||
with:
|
||||
crate: cargo-tarpaulin
|
||||
version: 0.14.2
|
||||
use-tool-cache: true
|
||||
- name: Test
|
||||
run: cargo test --all-features
|
||||
|
|
|
|||
|
|
@ -18,19 +18,13 @@
|
|||
-->
|
||||
|
||||
# Changelog
|
||||
All notable changes to this project will be documented in one of the linked
|
||||
files.
|
||||
All notable changes to this project will be documented in this file.
|
||||
|
||||
This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
|
||||
|
||||
Given that the parser produces a typed AST, any changes to the AST will
|
||||
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)
|
||||
- `0.51.0` and earlier: [changelog/0.51.0-pre.md](changelog/0.51.0-pre.md)
|
||||
|
|
|
|||
11
Cargo.toml
11
Cargo.toml
|
|
@ -18,7 +18,7 @@
|
|||
[package]
|
||||
name = "sqlparser"
|
||||
description = "Extensible SQL Lexer and Parser with support for ANSI SQL:2011"
|
||||
version = "0.57.0"
|
||||
version = "0.52.0"
|
||||
authors = ["Apache DataFusion <dev@datafusion.apache.org>"]
|
||||
homepage = "https://github.com/apache/datafusion-sqlparser-rs"
|
||||
documentation = "https://docs.rs/sqlparser/"
|
||||
|
|
@ -37,9 +37,8 @@ name = "sqlparser"
|
|||
path = "src/lib.rs"
|
||||
|
||||
[features]
|
||||
default = ["std", "recursive-protection"]
|
||||
default = ["std"]
|
||||
std = []
|
||||
recursive-protection = ["std", "recursive"]
|
||||
# Enable JSON output in the `cli` example:
|
||||
json_example = ["serde_json", "serde"]
|
||||
visitor = ["sqlparser_derive"]
|
||||
|
|
@ -47,14 +46,12 @@ visitor = ["sqlparser_derive"]
|
|||
[dependencies]
|
||||
bigdecimal = { version = "0.4.1", features = ["serde"], optional = true }
|
||||
log = "0.4"
|
||||
recursive = { version = "0.1.1", optional = true}
|
||||
|
||||
serde = { version = "1.0", default-features = false, features = ["derive", "alloc"], optional = true }
|
||||
serde = { version = "1.0", features = ["derive"], 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
|
||||
serde_json = { version = "1.0", optional = true }
|
||||
sqlparser_derive = { version = "0.3.0", path = "derive", optional = true }
|
||||
sqlparser_derive = { version = "0.2.0", path = "derive", optional = true }
|
||||
|
||||
[dev-dependencies]
|
||||
simple_logger = "5.0"
|
||||
|
|
|
|||
56
README.md
56
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([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 })]
|
||||
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 })]
|
||||
```
|
||||
|
||||
|
||||
|
|
@ -63,7 +63,7 @@ The following optional [crate features](https://doc.rust-lang.org/cargo/referen
|
|||
|
||||
* `serde`: Adds [Serde](https://serde.rs/) support by implementing `Serialize` and `Deserialize` for all AST nodes.
|
||||
* `visitor`: Adds a `Visitor` capable of recursively walking the AST tree.
|
||||
* `recursive-protection` (enabled by default), uses [recursive](https://docs.rs/recursive/latest/recursive/) for stack overflow protection.
|
||||
|
||||
|
||||
## Syntax vs Semantics
|
||||
|
||||
|
|
@ -89,14 +89,10 @@ 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
|
||||
|
|
@ -104,37 +100,15 @@ similar semantics are represented with the same AST. We welcome PRs to fix such
|
|||
issues and distinguish different syntaxes in the AST.
|
||||
|
||||
|
||||
## Source Locations (Work in Progress)
|
||||
|
||||
This crate allows recovering source locations from AST nodes via the [Spanned]
|
||||
trait, which can be used for advanced diagnostics tooling. Note that this
|
||||
feature is a work in progress and many nodes report missing or inaccurate spans.
|
||||
Please see [this ticket] for information on how to contribute missing
|
||||
improvements.
|
||||
|
||||
[Spanned]: https://docs.rs/sqlparser/latest/sqlparser/ast/trait.Spanned.html
|
||||
[this ticket]: https://github.com/apache/datafusion-sqlparser-rs/issues/1548
|
||||
|
||||
```rust
|
||||
// Parse SQL
|
||||
let ast = Parser::parse_sql(&GenericDialect, "SELECT A FROM B").unwrap();
|
||||
|
||||
// The source span can be retrieved with start and end locations
|
||||
assert_eq!(ast[0].span(), Span {
|
||||
start: Location::of(1, 1),
|
||||
end: Location::of(1, 16),
|
||||
});
|
||||
```
|
||||
|
||||
## SQL compliance
|
||||
|
||||
SQL was first standardized in 1987, and revisions of the standard have been
|
||||
published regularly since. Most revisions have added significant new features to
|
||||
the language, and as a result no database claims to support the full breadth of
|
||||
features. This parser currently supports most of the SQL-92 syntax, plus some
|
||||
syntax from newer versions that have been explicitly requested, plus various
|
||||
other dialect-specific syntax. Whenever possible, the [online SQL:2016
|
||||
grammar][sql-2016-grammar] is used to guide what syntax to accept.
|
||||
syntax from newer versions that have been explicitly requested, plus some MSSQL,
|
||||
PostgreSQL, and other dialect-specific syntax. Whenever possible, the [online
|
||||
SQL:2016 grammar][sql-2016-grammar] is used to guide what syntax to accept.
|
||||
|
||||
Unfortunately, stating anything more specific about compliance is difficult.
|
||||
There is no publicly available test suite that can assess compliance
|
||||
|
|
@ -160,8 +134,7 @@ $ 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], [ParadeDB], [CipherStash Proxy],
|
||||
and [GreptimeDB].
|
||||
[Ballista], [GlueSQL], [Opteryx], [Polars], [PRQL], [Qrlew], [JumpWire], and [ParadeDB].
|
||||
|
||||
If your project is using sqlparser-rs feel free to make a PR to add it
|
||||
to this list.
|
||||
|
|
@ -237,21 +210,6 @@ Our goal as maintainers is to facilitate the integration
|
|||
of various features from various contributors, but not to provide the
|
||||
implementations ourselves, as we simply don't have the resources.
|
||||
|
||||
### Benchmarking
|
||||
|
||||
There are several micro benchmarks in the `sqlparser_bench` directory.
|
||||
You can run them with:
|
||||
|
||||
```
|
||||
git checkout main
|
||||
cd sqlparser_bench
|
||||
cargo bench -- --save-baseline main
|
||||
git checkout <your branch>
|
||||
cargo bench -- --baseline main
|
||||
```
|
||||
|
||||
By adding the `--save-baseline main` and `--baseline main` you can track the
|
||||
progress of your improvements as you continue working on the feature branch.
|
||||
|
||||
## Licensing
|
||||
|
||||
|
|
@ -280,5 +238,3 @@ 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
|
||||
|
|
|
|||
|
|
@ -1,95 +0,0 @@
|
|||
<!--
|
||||
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.53.0 Changelog
|
||||
|
||||
This release consists of 47 commits from 16 contributors. See credits at the end of this changelog for more information.
|
||||
|
||||
**Other:**
|
||||
|
||||
- hive: support for special not expression `!a` and raise error for `a!` factorial operator [#1472](https://github.com/apache/datafusion-sqlparser-rs/pull/1472) (wugeer)
|
||||
- Add support for MSSQL's `OPENJSON WITH` clause [#1498](https://github.com/apache/datafusion-sqlparser-rs/pull/1498) (gaoqiangz)
|
||||
- Parse true and false as identifiers in mssql [#1510](https://github.com/apache/datafusion-sqlparser-rs/pull/1510) (lovasoa)
|
||||
- Fix the parsing error in MSSQL for multiple statements that include `DECLARE` statements [#1497](https://github.com/apache/datafusion-sqlparser-rs/pull/1497) (wugeer)
|
||||
- Add support for Snowflake SHOW DATABASES/SCHEMAS/TABLES/VIEWS/COLUMNS statements [#1501](https://github.com/apache/datafusion-sqlparser-rs/pull/1501) (yoavcloud)
|
||||
- Add support of COMMENT ON syntax for Snowflake [#1516](https://github.com/apache/datafusion-sqlparser-rs/pull/1516) (git-hulk)
|
||||
- Add support for MYSQL's `CREATE TABLE SELECT` expr [#1515](https://github.com/apache/datafusion-sqlparser-rs/pull/1515) (wugeer)
|
||||
- Add support for MSSQL's `XQuery` methods [#1500](https://github.com/apache/datafusion-sqlparser-rs/pull/1500) (gaoqiangz)
|
||||
- Add support for Hive's `LOAD DATA` expr [#1520](https://github.com/apache/datafusion-sqlparser-rs/pull/1520) (wugeer)
|
||||
- Fix ClickHouse document link from `Russian` to `English` [#1527](https://github.com/apache/datafusion-sqlparser-rs/pull/1527) (git-hulk)
|
||||
- Support ANTI and SEMI joins without LEFT/RIGHT [#1528](https://github.com/apache/datafusion-sqlparser-rs/pull/1528) (delamarch3)
|
||||
- support sqlite's OR clauses in update statements [#1530](https://github.com/apache/datafusion-sqlparser-rs/pull/1530) (lovasoa)
|
||||
- support column type definitions in table aliases [#1526](https://github.com/apache/datafusion-sqlparser-rs/pull/1526) (lovasoa)
|
||||
- Add support for MSSQL's `JSON_ARRAY`/`JSON_OBJECT` expr [#1507](https://github.com/apache/datafusion-sqlparser-rs/pull/1507) (gaoqiangz)
|
||||
- Add support for PostgreSQL `UNLISTEN` syntax and Add support for Postgres `LOAD extension` expr [#1531](https://github.com/apache/datafusion-sqlparser-rs/pull/1531) (wugeer)
|
||||
- Parse byte/bit string literals in MySQL and Postgres [#1532](https://github.com/apache/datafusion-sqlparser-rs/pull/1532) (mvzink)
|
||||
- Allow example CLI to read from stdin [#1536](https://github.com/apache/datafusion-sqlparser-rs/pull/1536) (mvzink)
|
||||
- recursive select calls are parsed with bad trailing_commas parameter [#1521](https://github.com/apache/datafusion-sqlparser-rs/pull/1521) (tomershaniii)
|
||||
- PartiQL queries in Redshift [#1534](https://github.com/apache/datafusion-sqlparser-rs/pull/1534) (yoavcloud)
|
||||
- Include license file in sqlparser_derive crate [#1543](https://github.com/apache/datafusion-sqlparser-rs/pull/1543) (ankane)
|
||||
- Fallback to identifier parsing if expression parsing fails [#1513](https://github.com/apache/datafusion-sqlparser-rs/pull/1513) (yoavcloud)
|
||||
- support `json_object('k':'v')` in postgres [#1546](https://github.com/apache/datafusion-sqlparser-rs/pull/1546) (lovasoa)
|
||||
- Document micro benchmarks [#1555](https://github.com/apache/datafusion-sqlparser-rs/pull/1555) (alamb)
|
||||
- Implement `Spanned` to retrieve source locations on AST nodes [#1435](https://github.com/apache/datafusion-sqlparser-rs/pull/1435) (Nyrox)
|
||||
- Fix error in benchmark queries [#1560](https://github.com/apache/datafusion-sqlparser-rs/pull/1560) (alamb)
|
||||
- Fix clippy warnings on rust 1.83 [#1570](https://github.com/apache/datafusion-sqlparser-rs/pull/1570) (iffyio)
|
||||
- Support relation visitor to visit the `Option` field [#1556](https://github.com/apache/datafusion-sqlparser-rs/pull/1556) (goldmedal)
|
||||
- Rename `TokenWithLocation` to `TokenWithSpan`, in backwards compatible way [#1562](https://github.com/apache/datafusion-sqlparser-rs/pull/1562) (alamb)
|
||||
- Support MySQL size variants for BLOB and TEXT columns [#1564](https://github.com/apache/datafusion-sqlparser-rs/pull/1564) (mvzink)
|
||||
- Increase version of sqlparser_derive from 0.2.2 to 0.3.0 [#1571](https://github.com/apache/datafusion-sqlparser-rs/pull/1571) (alamb)
|
||||
- `json_object('k' VALUE 'v')` in postgres [#1547](https://github.com/apache/datafusion-sqlparser-rs/pull/1547) (lovasoa)
|
||||
- Support snowflake double dot notation for object name [#1540](https://github.com/apache/datafusion-sqlparser-rs/pull/1540) (ayman-sigma)
|
||||
- Update comments / docs for `Spanned` [#1549](https://github.com/apache/datafusion-sqlparser-rs/pull/1549) (alamb)
|
||||
- Support Databricks struct literal [#1542](https://github.com/apache/datafusion-sqlparser-rs/pull/1542) (ayman-sigma)
|
||||
- Encapsulate CreateFunction [#1573](https://github.com/apache/datafusion-sqlparser-rs/pull/1573) (philipcristiano)
|
||||
- Support BIT column types [#1577](https://github.com/apache/datafusion-sqlparser-rs/pull/1577) (mvzink)
|
||||
- Support parsing optional nulls handling for unique constraint [#1567](https://github.com/apache/datafusion-sqlparser-rs/pull/1567) (mvzink)
|
||||
- Fix displaying WORK or TRANSACTION after BEGIN [#1565](https://github.com/apache/datafusion-sqlparser-rs/pull/1565) (mvzink)
|
||||
- Add support of the ENUM8|ENUM16 for ClickHouse dialect [#1574](https://github.com/apache/datafusion-sqlparser-rs/pull/1574) (git-hulk)
|
||||
- Parse Snowflake USE ROLE and USE SECONDARY ROLES [#1578](https://github.com/apache/datafusion-sqlparser-rs/pull/1578) (yoavcloud)
|
||||
- Snowflake ALTER TABLE clustering options [#1579](https://github.com/apache/datafusion-sqlparser-rs/pull/1579) (yoavcloud)
|
||||
- Support INSERT OVERWRITE INTO syntax [#1584](https://github.com/apache/datafusion-sqlparser-rs/pull/1584) (yuval-illumex)
|
||||
- Parse `INSERT` with subquery when lacking column names [#1586](https://github.com/apache/datafusion-sqlparser-rs/pull/1586) (iffyio)
|
||||
- Add support for ODBC functions [#1585](https://github.com/apache/datafusion-sqlparser-rs/pull/1585) (iffyio)
|
||||
|
||||
## Credits
|
||||
|
||||
Thank you to everyone who contributed to this release. Here is a breakdown of commits (PRs merged) per contributor.
|
||||
|
||||
```
|
||||
8 Andrew Lamb
|
||||
6 Michael Victor Zink
|
||||
5 Ophir LOJKINE
|
||||
5 Yoav Cohen
|
||||
5 wugeer
|
||||
3 Ifeanyi Ubah
|
||||
3 gaoqiangz
|
||||
3 hulk
|
||||
2 Ayman Elkfrawy
|
||||
1 Andrew Kane
|
||||
1 Jax Liu
|
||||
1 Mark-Oliver Junge
|
||||
1 Philip Cristiano
|
||||
1 Yuval Shkolar
|
||||
1 delamarch3
|
||||
1 tomershaniii
|
||||
```
|
||||
|
||||
Thank you also to everyone who contributed in other ways such as filing issues, reviewing PRs, and providing feedback on this release.
|
||||
|
||||
|
|
@ -1,118 +0,0 @@
|
|||
<!--
|
||||
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.54.0 Changelog
|
||||
|
||||
This release consists of 57 commits from 24 contributors. See credits at the end of this changelog for more information.
|
||||
|
||||
**Implemented enhancements:**
|
||||
|
||||
- feat: support `INSERT INTO [TABLE] FUNCTION` of Clickhouse [#1633](https://github.com/apache/datafusion-sqlparser-rs/pull/1633) (byte-sourcerer)
|
||||
|
||||
**Other:**
|
||||
|
||||
- Run cargo fmt on `derive` crate [#1595](https://github.com/apache/datafusion-sqlparser-rs/pull/1595) (alamb)
|
||||
- Add Apache license header to spans.rs [#1594](https://github.com/apache/datafusion-sqlparser-rs/pull/1594) (alamb)
|
||||
- Add support for BigQuery `ANY TYPE` data type [#1602](https://github.com/apache/datafusion-sqlparser-rs/pull/1602) (MartinSahlen)
|
||||
- Add support for TABLESAMPLE [#1580](https://github.com/apache/datafusion-sqlparser-rs/pull/1580) (yoavcloud)
|
||||
- Redshift: Fix parsing for quoted numbered columns [#1576](https://github.com/apache/datafusion-sqlparser-rs/pull/1576) (7phs)
|
||||
- Add the alter table ON COMMIT option to Snowflake [#1606](https://github.com/apache/datafusion-sqlparser-rs/pull/1606) (yoavcloud)
|
||||
- Support parsing `EXPLAIN ESTIMATE` of Clickhouse [#1605](https://github.com/apache/datafusion-sqlparser-rs/pull/1605) (byte-sourcerer)
|
||||
- Fix BigQuery hyphenated ObjectName with numbers [#1598](https://github.com/apache/datafusion-sqlparser-rs/pull/1598) (ayman-sigma)
|
||||
- Fix test compilation issue [#1609](https://github.com/apache/datafusion-sqlparser-rs/pull/1609) (iffyio)
|
||||
- Allow foreign table constraint without columns [#1608](https://github.com/apache/datafusion-sqlparser-rs/pull/1608) (ramnivas)
|
||||
- Support optional table for `ANALYZE` statement [#1599](https://github.com/apache/datafusion-sqlparser-rs/pull/1599) (yuyang-ok)
|
||||
- Support DOUBLE data types with precision for Mysql [#1611](https://github.com/apache/datafusion-sqlparser-rs/pull/1611) (artorias1024)
|
||||
- Add `#[recursive]` [#1522](https://github.com/apache/datafusion-sqlparser-rs/pull/1522) (blaginin)
|
||||
- Support arbitrary composite access expressions [#1600](https://github.com/apache/datafusion-sqlparser-rs/pull/1600) (ayman-sigma)
|
||||
- Consolidate `MapAccess`, and `Subscript` into `CompoundExpr` to handle the complex field access chain [#1551](https://github.com/apache/datafusion-sqlparser-rs/pull/1551) (goldmedal)
|
||||
- Handle empty projection in Postgres SELECT statements [#1613](https://github.com/apache/datafusion-sqlparser-rs/pull/1613) (tobyhede)
|
||||
- Merge composite and compound expr test cases [#1615](https://github.com/apache/datafusion-sqlparser-rs/pull/1615) (iffyio)
|
||||
- Support Snowflake Update-From-Select [#1604](https://github.com/apache/datafusion-sqlparser-rs/pull/1604) (yuval-illumex)
|
||||
- Improve parsing performance by reducing token cloning [#1587](https://github.com/apache/datafusion-sqlparser-rs/pull/1587) (davisp)
|
||||
- Improve Parser documentation [#1617](https://github.com/apache/datafusion-sqlparser-rs/pull/1617) (alamb)
|
||||
- Add support for DROP EXTENSION [#1610](https://github.com/apache/datafusion-sqlparser-rs/pull/1610) (ramnivas)
|
||||
- Refactor advancing token to avoid duplication, avoid borrow checker issues [#1618](https://github.com/apache/datafusion-sqlparser-rs/pull/1618) (alamb)
|
||||
- Fix the parsing result for the special double number [#1621](https://github.com/apache/datafusion-sqlparser-rs/pull/1621) (goldmedal)
|
||||
- SQLite: Allow dollar signs in placeholder names [#1620](https://github.com/apache/datafusion-sqlparser-rs/pull/1620) (hansott)
|
||||
- Improve error for an unexpected token after DROP [#1623](https://github.com/apache/datafusion-sqlparser-rs/pull/1623) (ramnivas)
|
||||
- Fix `sqlparser_bench` benchmark compilation [#1625](https://github.com/apache/datafusion-sqlparser-rs/pull/1625) (alamb)
|
||||
- Improve parsing speed by avoiding some clones in parse_identifier [#1624](https://github.com/apache/datafusion-sqlparser-rs/pull/1624) (alamb)
|
||||
- Simplify `parse_keyword_apis` more [#1626](https://github.com/apache/datafusion-sqlparser-rs/pull/1626) (alamb)
|
||||
- Test benchmarks and Improve benchmark README.md [#1627](https://github.com/apache/datafusion-sqlparser-rs/pull/1627) (alamb)
|
||||
- Add support for MYSQL's `RENAME TABLE` [#1616](https://github.com/apache/datafusion-sqlparser-rs/pull/1616) (wugeer)
|
||||
- Correctly tokenize nested comments [#1629](https://github.com/apache/datafusion-sqlparser-rs/pull/1629) (hansott)
|
||||
- Add support for USE SECONDARY ROLE (vs. ROLES) [#1637](https://github.com/apache/datafusion-sqlparser-rs/pull/1637) (yoavcloud)
|
||||
- Add support for various Snowflake grantees [#1640](https://github.com/apache/datafusion-sqlparser-rs/pull/1640) (yoavcloud)
|
||||
- Add support for the SQL OVERLAPS predicate [#1638](https://github.com/apache/datafusion-sqlparser-rs/pull/1638) (yoavcloud)
|
||||
- Add support for Snowflake LIST and REMOVE [#1639](https://github.com/apache/datafusion-sqlparser-rs/pull/1639) (yoavcloud)
|
||||
- Add support for MySQL's INSERT INTO ... SET syntax [#1641](https://github.com/apache/datafusion-sqlparser-rs/pull/1641) (yoavcloud)
|
||||
- Start new line if \r in Postgres dialect [#1647](https://github.com/apache/datafusion-sqlparser-rs/pull/1647) (hansott)
|
||||
- Support pluralized time units [#1630](https://github.com/apache/datafusion-sqlparser-rs/pull/1630) (wugeer)
|
||||
- Replace `ReferentialAction` enum in `DROP` statements [#1648](https://github.com/apache/datafusion-sqlparser-rs/pull/1648) (stepancheg)
|
||||
- Add support for MS-SQL BEGIN/END TRY/CATCH [#1649](https://github.com/apache/datafusion-sqlparser-rs/pull/1649) (yoavcloud)
|
||||
- Fix MySQL parsing of GRANT, REVOKE, and CREATE VIEW [#1538](https://github.com/apache/datafusion-sqlparser-rs/pull/1538) (mvzink)
|
||||
- Add support for the Snowflake MINUS set operator [#1652](https://github.com/apache/datafusion-sqlparser-rs/pull/1652) (yoavcloud)
|
||||
- ALTER TABLE DROP {COLUMN|CONSTRAINT} RESTRICT [#1651](https://github.com/apache/datafusion-sqlparser-rs/pull/1651) (stepancheg)
|
||||
- Add support for ClickHouse `FORMAT` on `INSERT` [#1628](https://github.com/apache/datafusion-sqlparser-rs/pull/1628) (bombsimon)
|
||||
- MsSQL SET for session params [#1646](https://github.com/apache/datafusion-sqlparser-rs/pull/1646) (yoavcloud)
|
||||
- Correctly look for end delimiter dollar quoted string [#1650](https://github.com/apache/datafusion-sqlparser-rs/pull/1650) (hansott)
|
||||
- Support single line comments starting with '#' for Hive [#1654](https://github.com/apache/datafusion-sqlparser-rs/pull/1654) (wugeer)
|
||||
- Support trailing commas in `FROM` clause [#1645](https://github.com/apache/datafusion-sqlparser-rs/pull/1645) (barsela1)
|
||||
- Allow empty options for BigQuery [#1657](https://github.com/apache/datafusion-sqlparser-rs/pull/1657) (MartinSahlen)
|
||||
- Add support for parsing RAISERROR [#1656](https://github.com/apache/datafusion-sqlparser-rs/pull/1656) (AvivDavid-Satori)
|
||||
- Add support for Snowflake column aliases that use SQL keywords [#1632](https://github.com/apache/datafusion-sqlparser-rs/pull/1632) (yoavcloud)
|
||||
- fix parsing of `INSERT INTO ... SELECT ... RETURNING ` [#1661](https://github.com/apache/datafusion-sqlparser-rs/pull/1661) (lovasoa)
|
||||
- Add support for `IS [NOT] [form] NORMALIZED` [#1655](https://github.com/apache/datafusion-sqlparser-rs/pull/1655) (alexander-beedie)
|
||||
- Add support for qualified column names in JOIN ... USING [#1663](https://github.com/apache/datafusion-sqlparser-rs/pull/1663) (yoavcloud)
|
||||
- Add support for Snowflake AT/BEFORE [#1667](https://github.com/apache/datafusion-sqlparser-rs/pull/1667) (yoavcloud)
|
||||
|
||||
## Credits
|
||||
|
||||
Thank you to everyone who contributed to this release. Here is a breakdown of commits (PRs merged) per contributor.
|
||||
|
||||
```
|
||||
13 Yoav Cohen
|
||||
9 Andrew Lamb
|
||||
4 Hans Ott
|
||||
3 Ramnivas Laddad
|
||||
3 wugeer
|
||||
2 Ayman Elkfrawy
|
||||
2 Ifeanyi Ubah
|
||||
2 Jax Liu
|
||||
2 Martin Abelson Sahlen
|
||||
2 Stepan Koltsov
|
||||
2 cjw
|
||||
1 Aleksei Piianin
|
||||
1 Alexander Beedie
|
||||
1 AvivDavid-Satori
|
||||
1 Dmitrii Blaginin
|
||||
1 Michael Victor Zink
|
||||
1 Ophir LOJKINE
|
||||
1 Paul J. Davis
|
||||
1 Simon Sawert
|
||||
1 Toby Hede
|
||||
1 Yuval Shkolar
|
||||
1 artorias1024
|
||||
1 bar sela
|
||||
1 yuyang
|
||||
```
|
||||
|
||||
Thank you also to everyone who contributed in other ways such as filing issues, reviewing PRs, and providing feedback on this release.
|
||||
|
||||
|
|
@ -1,173 +0,0 @@
|
|||
<!--
|
||||
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.
|
||||
|
||||
|
|
@ -1,102 +0,0 @@
|
|||
<!--
|
||||
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.
|
||||
|
||||
|
|
@ -1,95 +0,0 @@
|
|||
<!--
|
||||
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.
|
||||
|
||||
|
|
@ -17,8 +17,8 @@
|
|||
|
||||
[package]
|
||||
name = "sqlparser_derive"
|
||||
description = "Procedural (proc) macros for sqlparser"
|
||||
version = "0.3.0"
|
||||
description = "proc macro for sqlparser"
|
||||
version = "0.2.2"
|
||||
authors = ["sqlparser-rs authors"]
|
||||
homepage = "https://github.com/sqlparser-rs/sqlparser-rs"
|
||||
documentation = "https://docs.rs/sqlparser_derive/"
|
||||
|
|
@ -28,7 +28,6 @@ license = "Apache-2.0"
|
|||
include = [
|
||||
"src/**/*.rs",
|
||||
"Cargo.toml",
|
||||
"LICENSE.TXT",
|
||||
]
|
||||
edition = "2021"
|
||||
|
||||
|
|
|
|||
|
|
@ -1 +0,0 @@
|
|||
../LICENSE.TXT
|
||||
|
|
@ -151,55 +151,6 @@ visitor.post_visit_expr(<is null operand>)
|
|||
visitor.post_visit_expr(<is null expr>)
|
||||
```
|
||||
|
||||
If the field is a `Option` and add `#[with = "visit_xxx"]` to the field, the generated code
|
||||
will try to access the field only if it is `Some`:
|
||||
|
||||
```rust
|
||||
#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
|
||||
pub struct ShowStatementIn {
|
||||
pub clause: ShowStatementInClause,
|
||||
pub parent_type: Option<ShowStatementInParentType>,
|
||||
#[cfg_attr(feature = "visitor", visit(with = "visit_relation"))]
|
||||
pub parent_name: Option<ObjectName>,
|
||||
}
|
||||
```
|
||||
|
||||
This will generate
|
||||
|
||||
```rust
|
||||
impl sqlparser::ast::Visit for ShowStatementIn {
|
||||
fn visit<V: sqlparser::ast::Visitor>(
|
||||
&self,
|
||||
visitor: &mut V,
|
||||
) -> ::std::ops::ControlFlow<V::Break> {
|
||||
sqlparser::ast::Visit::visit(&self.clause, visitor)?;
|
||||
sqlparser::ast::Visit::visit(&self.parent_type, visitor)?;
|
||||
if let Some(value) = &self.parent_name {
|
||||
visitor.pre_visit_relation(value)?;
|
||||
sqlparser::ast::Visit::visit(value, visitor)?;
|
||||
visitor.post_visit_relation(value)?;
|
||||
}
|
||||
::std::ops::ControlFlow::Continue(())
|
||||
}
|
||||
}
|
||||
|
||||
impl sqlparser::ast::VisitMut for ShowStatementIn {
|
||||
fn visit<V: sqlparser::ast::VisitorMut>(
|
||||
&mut self,
|
||||
visitor: &mut V,
|
||||
) -> ::std::ops::ControlFlow<V::Break> {
|
||||
sqlparser::ast::VisitMut::visit(&mut self.clause, visitor)?;
|
||||
sqlparser::ast::VisitMut::visit(&mut self.parent_type, visitor)?;
|
||||
if let Some(value) = &mut self.parent_name {
|
||||
visitor.pre_visit_relation(value)?;
|
||||
sqlparser::ast::VisitMut::visit(value, visitor)?;
|
||||
visitor.post_visit_relation(value)?;
|
||||
}
|
||||
::std::ops::ControlFlow::Continue(())
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## Releasing
|
||||
|
||||
This crate's release is not automated. Instead it is released manually as needed
|
||||
|
|
|
|||
|
|
@ -21,9 +21,8 @@ use syn::spanned::Spanned;
|
|||
use syn::{
|
||||
parse::{Parse, ParseStream},
|
||||
parse_macro_input, parse_quote, Attribute, Data, DeriveInput, Fields, GenericParam, Generics,
|
||||
Ident, Index, LitStr, Meta, Token, Type, TypePath,
|
||||
Ident, Index, LitStr, Meta, Token,
|
||||
};
|
||||
use syn::{Path, PathArguments};
|
||||
|
||||
/// Implementation of `[#derive(Visit)]`
|
||||
#[proc_macro_derive(VisitMut, attributes(visit))]
|
||||
|
|
@ -78,10 +77,7 @@ fn derive_visit(input: proc_macro::TokenStream, visit_type: &VisitType) -> proc_
|
|||
|
||||
let expanded = quote! {
|
||||
// The generated impl.
|
||||
// Note that it uses [`recursive::recursive`] to protect from stack overflow.
|
||||
// See tests in https://github.com/apache/datafusion-sqlparser-rs/pull/1522/ for more info.
|
||||
impl #impl_generics sqlparser::ast::#visit_trait for #name #ty_generics #where_clause {
|
||||
#[cfg_attr(feature = "recursive-protection", recursive::recursive)]
|
||||
fn visit<V: sqlparser::ast::#visitor_trait>(
|
||||
&#modifier self,
|
||||
visitor: &mut V
|
||||
|
|
@ -186,21 +182,9 @@ fn visit_children(
|
|||
Fields::Named(fields) => {
|
||||
let recurse = fields.named.iter().map(|f| {
|
||||
let name = &f.ident;
|
||||
let is_option = is_option(&f.ty);
|
||||
let attributes = Attributes::parse(&f.attrs);
|
||||
if is_option && attributes.with.is_some() {
|
||||
let (pre_visit, post_visit) = attributes.visit(quote!(value));
|
||||
quote_spanned!(f.span() =>
|
||||
if let Some(value) = &#modifier self.#name {
|
||||
#pre_visit sqlparser::ast::#visit_trait::visit(value, visitor)?; #post_visit
|
||||
}
|
||||
)
|
||||
} else {
|
||||
let (pre_visit, post_visit) = attributes.visit(quote!(&#modifier self.#name));
|
||||
quote_spanned!(f.span() =>
|
||||
#pre_visit sqlparser::ast::#visit_trait::visit(&#modifier self.#name, visitor)?; #post_visit
|
||||
)
|
||||
}
|
||||
let (pre_visit, post_visit) = attributes.visit(quote!(&#modifier self.#name));
|
||||
quote_spanned!(f.span() => #pre_visit sqlparser::ast::#visit_trait::visit(&#modifier self.#name, visitor)?; #post_visit)
|
||||
});
|
||||
quote! {
|
||||
#(#recurse)*
|
||||
|
|
@ -272,20 +256,3 @@ fn visit_children(
|
|||
Data::Union(_) => unimplemented!(),
|
||||
}
|
||||
}
|
||||
|
||||
fn is_option(ty: &Type) -> bool {
|
||||
if let Type::Path(TypePath {
|
||||
path: Path { segments, .. },
|
||||
..
|
||||
}) = ty
|
||||
{
|
||||
if let Some(segment) = segments.last() {
|
||||
if segment.ident == "Option" {
|
||||
if let PathArguments::AngleBracketed(args) = &segment.arguments {
|
||||
return args.args.len() == 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
false
|
||||
}
|
||||
|
|
|
|||
|
|
@ -146,12 +146,6 @@ Move artifacts to the release location in SVN, using the `release-tarball.sh` sc
|
|||
```shell
|
||||
./dev/release/release-tarball.sh 0.52.0 1
|
||||
```
|
||||
|
||||
Promote the rc tag to the release tag
|
||||
```shell
|
||||
git tag v0.52.0 v0.52.0-rc3
|
||||
git push apache v0.52.0
|
||||
```
|
||||
|
||||
Congratulations! The release is now official!
|
||||
|
||||
|
|
|
|||
|
|
@ -28,8 +28,7 @@ def print_pulls(repo_name, title, pulls):
|
|||
print()
|
||||
for (pull, commit) in pulls:
|
||||
url = "https://github.com/{}/pull/{}".format(repo_name, pull.number)
|
||||
author = f"({commit.author.login})" if commit.author else ''
|
||||
print("- {} [#{}]({}) {}".format(pull.title, pull.number, url, author))
|
||||
print("- {} [#{}]({}) ({})".format(pull.title, pull.number, url, commit.author.login))
|
||||
print()
|
||||
|
||||
|
||||
|
|
@ -162,4 +161,4 @@ def cli(args=None):
|
|||
generate_changelog(repo, project, args.tag1, args.tag2, args.version)
|
||||
|
||||
if __name__ == "__main__":
|
||||
cli()
|
||||
cli()
|
||||
|
|
@ -1,8 +1,6 @@
|
|||
# Files to exclude from the Apache Rat (license) check
|
||||
.gitignore
|
||||
.tool-versions
|
||||
target/*
|
||||
**.gitignore
|
||||
rat.txt
|
||||
dev/release/rat_exclude_files.txt
|
||||
sqlparser_bench/img/flamegraph.svg
|
||||
**Cargo.lock
|
||||
filtered_rat.txt
|
||||
fuzz/.gitignore
|
||||
|
||||
|
|
|
|||
|
|
@ -17,11 +17,9 @@
|
|||
|
||||
#![warn(clippy::all)]
|
||||
|
||||
//! A small command-line app to run the parser.
|
||||
//! Run with `cargo run --example cli`
|
||||
|
||||
/// A small command-line app to run the parser.
|
||||
/// Run with `cargo run --example cli`
|
||||
use std::fs;
|
||||
use std::io::{stdin, Read};
|
||||
|
||||
use simple_logger::SimpleLogger;
|
||||
use sqlparser::dialect::*;
|
||||
|
|
@ -40,9 +38,6 @@ $ cargo run --example cli FILENAME.sql [--dialectname]
|
|||
To print the parse results as JSON:
|
||||
$ cargo run --feature json_example --example cli FILENAME.sql [--dialectname]
|
||||
|
||||
To read from stdin instead of a file:
|
||||
$ cargo run --example cli - [--dialectname]
|
||||
|
||||
"#,
|
||||
);
|
||||
|
||||
|
|
@ -62,18 +57,9 @@ $ cargo run --example cli - [--dialectname]
|
|||
s => panic!("Unexpected parameter: {s}"),
|
||||
};
|
||||
|
||||
let contents = if filename == "-" {
|
||||
println!("Parsing from stdin using {dialect:?}");
|
||||
let mut buf = Vec::new();
|
||||
stdin()
|
||||
.read_to_end(&mut buf)
|
||||
.expect("failed to read from stdin");
|
||||
String::from_utf8(buf).expect("stdin content wasn't valid utf8")
|
||||
} else {
|
||||
println!("Parsing from file '{}' using {:?}", &filename, dialect);
|
||||
fs::read_to_string(&filename)
|
||||
.unwrap_or_else(|_| panic!("Unable to read the file {}", &filename))
|
||||
};
|
||||
println!("Parsing from file '{}' using {:?}", &filename, dialect);
|
||||
let contents = fs::read_to_string(&filename)
|
||||
.unwrap_or_else(|_| panic!("Unable to read the file {}", &filename));
|
||||
let without_bom = if contents.chars().next().unwrap() as u64 != 0xfeff {
|
||||
contents.as_str()
|
||||
} else {
|
||||
|
|
|
|||
|
|
@ -17,7 +17,6 @@
|
|||
|
||||
[package]
|
||||
name = "sqlparser_bench"
|
||||
description = "Benchmarks for sqlparser"
|
||||
version = "0.1.0"
|
||||
authors = ["Dandandan <danielheres@gmail.com>"]
|
||||
edition = "2018"
|
||||
|
|
@ -26,7 +25,7 @@ edition = "2018"
|
|||
sqlparser = { path = "../" }
|
||||
|
||||
[dev-dependencies]
|
||||
criterion = "0.6"
|
||||
criterion = "0.5"
|
||||
|
||||
[[bench]]
|
||||
name = "sqlparser_bench"
|
||||
|
|
|
|||
|
|
@ -1,42 +0,0 @@
|
|||
<!---
|
||||
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.
|
||||
-->
|
||||
|
||||
Benchmarks for sqlparser. See [the main README](../README.md) for more information.
|
||||
|
||||
Note: this is in a separate, non workspace crate to avoid adding a dependency
|
||||
on `criterion` to the main crate (which complicates testing without std).
|
||||
|
||||
# Running Benchmarks
|
||||
|
||||
```shell
|
||||
cargo bench --bench sqlparser_bench
|
||||
```
|
||||
|
||||
# Profiling
|
||||
|
||||
Note you can generate a [flamegraph] using the following command:
|
||||
|
||||
```shell
|
||||
cargo flamegraph --bench sqlparser_bench
|
||||
```
|
||||
|
||||
[flamegraph]: https://crates.io/crates/flamegraph
|
||||
|
||||
Here is an example flamegraph:
|
||||
|
||||
|
|
@ -23,9 +23,9 @@ fn basic_queries(c: &mut Criterion) {
|
|||
let mut group = c.benchmark_group("sqlparser-rs parsing benchmark");
|
||||
let dialect = GenericDialect {};
|
||||
|
||||
let string = "SELECT * FROM my_table WHERE 1 = 1";
|
||||
let string = "SELECT * FROM table WHERE 1 = 1";
|
||||
group.bench_function("sqlparser::select", |b| {
|
||||
b.iter(|| Parser::parse_sql(&dialect, string).unwrap());
|
||||
b.iter(|| Parser::parse_sql(&dialect, string));
|
||||
});
|
||||
|
||||
let with_query = "
|
||||
|
|
@ -33,52 +33,14 @@ fn basic_queries(c: &mut Criterion) {
|
|||
SELECT MAX(a) AS max_a,
|
||||
COUNT(b) AS b_num,
|
||||
user_id
|
||||
FROM MY_TABLE
|
||||
FROM TABLE
|
||||
GROUP BY user_id
|
||||
)
|
||||
SELECT * FROM my_table
|
||||
SELECT * FROM table
|
||||
LEFT JOIN derived USING (user_id)
|
||||
";
|
||||
group.bench_function("sqlparser::with_select", |b| {
|
||||
b.iter(|| Parser::parse_sql(&dialect, with_query).unwrap());
|
||||
});
|
||||
|
||||
let large_statement = {
|
||||
let expressions = (0..1000)
|
||||
.map(|n| format!("FN_{n}(COL_{n})"))
|
||||
.collect::<Vec<_>>()
|
||||
.join(", ");
|
||||
let tables = (0..1000)
|
||||
.map(|n| format!("TABLE_{n}"))
|
||||
.collect::<Vec<_>>()
|
||||
.join(" JOIN ");
|
||||
let where_condition = (0..1000)
|
||||
.map(|n| format!("COL_{n} = {n}"))
|
||||
.collect::<Vec<_>>()
|
||||
.join(" OR ");
|
||||
let order_condition = (0..1000)
|
||||
.map(|n| format!("COL_{n} DESC"))
|
||||
.collect::<Vec<_>>()
|
||||
.join(", ");
|
||||
|
||||
format!(
|
||||
"SELECT {expressions} FROM {tables} WHERE {where_condition} ORDER BY {order_condition}"
|
||||
)
|
||||
};
|
||||
|
||||
group.bench_function("parse_large_statement", |b| {
|
||||
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())
|
||||
.unwrap()
|
||||
.pop()
|
||||
.unwrap();
|
||||
|
||||
group.bench_function("format_large_statement", |b| {
|
||||
b.iter(|| {
|
||||
let _formatted_query = large_statement.to_string();
|
||||
});
|
||||
b.iter(|| Parser::parse_sql(&dialect, with_query));
|
||||
});
|
||||
}
|
||||
|
||||
|
|
|
|||
File diff suppressed because one or more lines are too long
|
Before Width: | Height: | Size: 1.5 MiB |
|
|
@ -25,435 +25,309 @@ use serde::{Deserialize, Serialize};
|
|||
#[cfg(feature = "visitor")]
|
||||
use sqlparser_derive::{Visit, VisitMut};
|
||||
|
||||
use crate::ast::{display_comma_separated, Expr, ObjectName, StructField, UnionField};
|
||||
use crate::ast::{display_comma_separated, ObjectName, StructField, UnionField};
|
||||
|
||||
use super::{value::escape_single_quote_string, ColumnDef};
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
|
||||
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
|
||||
#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
|
||||
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)
|
||||
NamedValue(String, Expr),
|
||||
}
|
||||
|
||||
/// SQL data types
|
||||
#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
|
||||
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
|
||||
#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
|
||||
pub enum DataType {
|
||||
/// 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).
|
||||
/// 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), [SQL Standard].
|
||||
/// Large character object with optional length e.g. CHARACTER LARGE OBJECT, CHARACTER LARGE OBJECT(1000), [standard]
|
||||
///
|
||||
/// [SQL Standard]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#character-large-object-type
|
||||
/// [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), [SQL Standard].
|
||||
/// Large character object with optional length e.g. CHAR LARGE OBJECT, CHAR LARGE OBJECT(1000), [standard]
|
||||
///
|
||||
/// [SQL Standard]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#character-large-object-type
|
||||
/// [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), [SQL Standard].
|
||||
/// Large character object with optional length e.g. CLOB, CLOB(1000), [standard]
|
||||
///
|
||||
/// [SQL Standard]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#character-large-object-type
|
||||
/// [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,
|
||||
/// see [SQL Standard], [MS SQL Server].
|
||||
/// Fixed-length binary type with optional length e.g. [standard], [MS SQL Server]
|
||||
///
|
||||
/// [SQL Standard]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#binary-string-type
|
||||
/// [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,
|
||||
/// see [SQL Standard], [MS SQL Server].
|
||||
/// Variable-length binary with optional length type e.g. [standard], [MS SQL Server]
|
||||
///
|
||||
/// [SQL Standard]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#binary-string-type
|
||||
/// [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<BinaryLength>),
|
||||
/// Large binary object with optional length,
|
||||
/// see [SQL Standard], [Oracle].
|
||||
Varbinary(Option<u64>),
|
||||
/// Large binary object with optional length e.g. BLOB, BLOB(1000), [standard], [Oracle]
|
||||
///
|
||||
/// [SQL Standard]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#binary-large-object-string-type
|
||||
/// [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]: https://dev.mysql.com/doc/refman/9.1/en/blob.html
|
||||
TinyBlob,
|
||||
/// [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]: 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), [SQL Standard][1].
|
||||
/// Numeric type with optional precision and scale e.g. NUMERIC(10,2), [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), [SQL Standard][1].
|
||||
/// Decimal type with optional precision and scale e.g. DECIMAL(10,2), [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), [SQL Standard][1].
|
||||
/// Dec type with optional precision and scale e.g. DEC(10,2), [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.
|
||||
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).
|
||||
/// 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)
|
||||
///
|
||||
/// [PostgreSQL]: https://www.postgresql.org/docs/current/datatype.html
|
||||
/// [postgresql]: https://www.postgresql.org/docs/15/datatype.html
|
||||
Int2(Option<u64>),
|
||||
/// 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).
|
||||
/// 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)
|
||||
SmallInt(Option<u64>),
|
||||
/// 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).
|
||||
/// 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)
|
||||
///
|
||||
/// [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
|
||||
MediumIntUnsigned(Option<u64>),
|
||||
/// Int with optional display width, e.g. INT or INT(11).
|
||||
UnsignedMediumInt(Option<u64>),
|
||||
/// Int with optional display width e.g. INT or INT(11)
|
||||
Int(Option<u64>),
|
||||
/// 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).
|
||||
/// 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)
|
||||
///
|
||||
/// [PostgreSQL]: https://www.postgresql.org/docs/current/datatype.html
|
||||
/// [postgresql]: https://www.postgresql.org/docs/15/datatype.html
|
||||
Int4(Option<u64>),
|
||||
/// 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].
|
||||
/// 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]
|
||||
///
|
||||
/// [PostgreSQL]: https://www.postgresql.org/docs/current/datatype.html
|
||||
/// [ClickHouse]: https://clickhouse.com/docs/en/sql-reference/data-types/int-uint
|
||||
/// [postgresql]: https://www.postgresql.org/docs/15/datatype.html
|
||||
/// [clickhouse]: https://clickhouse.com/docs/en/sql-reference/data-types/int-uint
|
||||
Int8(Option<u64>),
|
||||
/// Integer type in [ClickHouse].
|
||||
/// Note: Int16 means 16 bits in [ClickHouse].
|
||||
/// Integer type in [clickhouse]
|
||||
/// Note: Int16 mean 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: Int32 means 32 bits in [ClickHouse].
|
||||
/// Integer type in [clickhouse]
|
||||
/// Note: Int16 mean 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 means 128 bits in [ClickHouse].
|
||||
/// Integer type in [clickhouse]
|
||||
/// Note: Int128 mean 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 means 256 bits in [ClickHouse].
|
||||
/// Integer type in [clickhouse]
|
||||
/// Note: Int256 mean 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.
|
||||
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].
|
||||
/// 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]
|
||||
///
|
||||
/// [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 means 16 bits in [ClickHouse].
|
||||
/// Unsigned integer type in [clickhouse]
|
||||
/// Note: UInt16 mean 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 means 32 bits in [ClickHouse].
|
||||
/// Unsigned integer type in [clickhouse]
|
||||
/// Note: UInt32 mean 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 means 64 bits in [ClickHouse].
|
||||
/// Unsigned integer type in [clickhouse]
|
||||
/// Note: UInt64 mean 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 means 128 bits in [ClickHouse].
|
||||
/// Unsigned integer type in [clickhouse]
|
||||
/// Note: UInt128 mean 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 means 256 bits in [ClickHouse].
|
||||
/// Unsigned integer type in [clickhouse]
|
||||
/// Note: UInt256 mean 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.
|
||||
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`
|
||||
/// 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]
|
||||
///
|
||||
/// [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
|
||||
/// [postgresql]: https://www.postgresql.org/docs/15/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 is an alias for Double in [PostgreSQL].
|
||||
/// Float8 as alias for Double in [postgresql]
|
||||
///
|
||||
/// [PostgreSQL]: https://www.postgresql.org/docs/current/datatype.html
|
||||
/// [postgresql]: https://www.postgresql.org/docs/15/datatype.html
|
||||
Float8,
|
||||
/// Double
|
||||
Double(ExactNumberInfo),
|
||||
/// Double Precision, see [SQL Standard], [PostgreSQL].
|
||||
Double,
|
||||
/// Double PRECISION e.g. [standard], [postgresql]
|
||||
///
|
||||
/// [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
|
||||
/// [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 is an alias for Boolean, see [PostgreSQL].
|
||||
/// Bool as alias for Boolean in [postgresql]
|
||||
///
|
||||
/// [PostgreSQL]: https://www.postgresql.org/docs/current/datatype.html
|
||||
/// [postgresql]: https://www.postgresql.org/docs/15/datatype.html
|
||||
Bool,
|
||||
/// Boolean type.
|
||||
/// Boolean
|
||||
Boolean,
|
||||
/// Date type.
|
||||
/// Date
|
||||
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, see [SQL Standard][1].
|
||||
/// Time with optional time precision and time zone information e.g. [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, see [MySQL][1].
|
||||
/// Datetime with optional time precision e.g. [MySQL][1].
|
||||
///
|
||||
/// [1]: https://dev.mysql.com/doc/refman/8.0/en/datetime.html
|
||||
Datetime(Option<u64>),
|
||||
/// Datetime with time precision and optional timezone, see [ClickHouse][1].
|
||||
/// Datetime with time precision and optional timezone e.g. [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, see [SQL Standard][1].
|
||||
/// Timestamp with optional time precision and time zone information e.g. [standard][1].
|
||||
///
|
||||
/// [1]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#datetime-type
|
||||
Timestamp(Option<u64>, TimezoneInfo),
|
||||
/// 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
|
||||
Interval,
|
||||
/// JSON type.
|
||||
/// JSON type
|
||||
JSON,
|
||||
/// Binary JSON type.
|
||||
/// Binary JSON type
|
||||
JSONB,
|
||||
/// Regclass used in [PostgreSQL] serial.
|
||||
///
|
||||
/// [PostgreSQL]: https://www.postgresql.org/docs/current/datatype.html
|
||||
/// Regclass used in postgresql serial
|
||||
Regclass,
|
||||
/// Text type.
|
||||
/// Text
|
||||
Text,
|
||||
/// [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]: https://dev.mysql.com/doc/refman/9.1/en/blob.html
|
||||
MediumText,
|
||||
/// [MySQL] text with up to 2**32 bytes.
|
||||
///
|
||||
/// [MySQL]: https://dev.mysql.com/doc/refman/9.1/en/blob.html
|
||||
LongText,
|
||||
/// String with optional length.
|
||||
String(Option<u64>),
|
||||
/// A fixed-length string e.g [ClickHouse][1].
|
||||
///
|
||||
/// [1]: https://clickhouse.com/docs/en/sql-reference/data-types/fixedstring
|
||||
FixedString(u64),
|
||||
/// Bytea type, see [PostgreSQL].
|
||||
///
|
||||
/// [PostgreSQL]: https://www.postgresql.org/docs/current/datatype-bit.html
|
||||
/// Bytea
|
||||
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>),
|
||||
/// `BIT VARYING(n)`: Variable-length bit string, see [PostgreSQL].
|
||||
///
|
||||
/// [PostgreSQL]: https://www.postgresql.org/docs/current/datatype-bit.html
|
||||
BitVarying(Option<u64>),
|
||||
/// `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 type such as enums
|
||||
Custom(ObjectName, Vec<String>),
|
||||
/// Arrays.
|
||||
/// Arrays
|
||||
Array(ArrayElemTypeDef),
|
||||
/// Map, see [ClickHouse].
|
||||
/// Map
|
||||
///
|
||||
/// [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, see [ClickHouse].
|
||||
/// Tuple
|
||||
///
|
||||
/// [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 type, see [ClickHouse].
|
||||
/// Nested
|
||||
///
|
||||
/// [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>),
|
||||
/// Enum type.
|
||||
Enum(Vec<EnumMember>, Option<u8>),
|
||||
/// Set type.
|
||||
/// Enums
|
||||
Enum(Vec<String>),
|
||||
/// Set
|
||||
Set(Vec<String>),
|
||||
/// Struct type, see [Hive], [BigQuery].
|
||||
/// Struct
|
||||
///
|
||||
/// [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 type, see [DuckDB].
|
||||
/// Union
|
||||
///
|
||||
/// [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, see [PostgreSQL].
|
||||
/// Trigger data type, returned by functions associated with triggers
|
||||
///
|
||||
/// [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, see [BigQuery].
|
||||
///
|
||||
/// [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 {
|
||||
|
|
@ -464,6 +338,7 @@ impl fmt::Display for DataType {
|
|||
DataType::CharacterVarying(size) => {
|
||||
format_character_string_type(f, "CHARACTER VARYING", size)
|
||||
}
|
||||
|
||||
DataType::CharVarying(size) => format_character_string_type(f, "CHAR VARYING", size),
|
||||
DataType::Varchar(size) => format_character_string_type(f, "VARCHAR", size),
|
||||
DataType::Nvarchar(size) => format_character_string_type(f, "NVARCHAR", size),
|
||||
|
|
@ -476,11 +351,10 @@ 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_varbinary_type(f, "VARBINARY", size),
|
||||
DataType::Varbinary(size) => {
|
||||
format_type_with_optional_length(f, "VARBINARY", size, false)
|
||||
}
|
||||
DataType::Blob(size) => format_type_with_optional_length(f, "BLOB", size, false),
|
||||
DataType::TinyBlob => write!(f, "TINYBLOB"),
|
||||
DataType::MediumBlob => write!(f, "MEDIUMBLOB"),
|
||||
DataType::LongBlob => write!(f, "LONGBLOB"),
|
||||
DataType::Bytes(size) => format_type_with_optional_length(f, "BYTES", size, false),
|
||||
DataType::Numeric(info) => {
|
||||
write!(f, "NUMERIC{info}")
|
||||
|
|
@ -497,29 +371,29 @@ impl fmt::Display for DataType {
|
|||
DataType::TinyInt(zerofill) => {
|
||||
format_type_with_optional_length(f, "TINYINT", zerofill, false)
|
||||
}
|
||||
DataType::TinyIntUnsigned(zerofill) => {
|
||||
DataType::UnsignedTinyInt(zerofill) => {
|
||||
format_type_with_optional_length(f, "TINYINT", zerofill, true)
|
||||
}
|
||||
DataType::Int2(zerofill) => {
|
||||
format_type_with_optional_length(f, "INT2", zerofill, false)
|
||||
}
|
||||
DataType::Int2Unsigned(zerofill) => {
|
||||
DataType::UnsignedInt2(zerofill) => {
|
||||
format_type_with_optional_length(f, "INT2", zerofill, true)
|
||||
}
|
||||
DataType::SmallInt(zerofill) => {
|
||||
format_type_with_optional_length(f, "SMALLINT", zerofill, false)
|
||||
}
|
||||
DataType::SmallIntUnsigned(zerofill) => {
|
||||
DataType::UnsignedSmallInt(zerofill) => {
|
||||
format_type_with_optional_length(f, "SMALLINT", zerofill, true)
|
||||
}
|
||||
DataType::MediumInt(zerofill) => {
|
||||
format_type_with_optional_length(f, "MEDIUMINT", zerofill, false)
|
||||
}
|
||||
DataType::MediumIntUnsigned(zerofill) => {
|
||||
DataType::UnsignedMediumInt(zerofill) => {
|
||||
format_type_with_optional_length(f, "MEDIUMINT", zerofill, true)
|
||||
}
|
||||
DataType::Int(zerofill) => format_type_with_optional_length(f, "INT", zerofill, false),
|
||||
DataType::IntUnsigned(zerofill) => {
|
||||
DataType::UnsignedInt(zerofill) => {
|
||||
format_type_with_optional_length(f, "INT", zerofill, true)
|
||||
}
|
||||
DataType::Int4(zerofill) => {
|
||||
|
|
@ -543,39 +417,24 @@ impl fmt::Display for DataType {
|
|||
DataType::Int256 => {
|
||||
write!(f, "Int256")
|
||||
}
|
||||
DataType::HugeInt => {
|
||||
write!(f, "HUGEINT")
|
||||
}
|
||||
DataType::Int4Unsigned(zerofill) => {
|
||||
DataType::UnsignedInt4(zerofill) => {
|
||||
format_type_with_optional_length(f, "INT4", zerofill, true)
|
||||
}
|
||||
DataType::Integer(zerofill) => {
|
||||
format_type_with_optional_length(f, "INTEGER", zerofill, false)
|
||||
}
|
||||
DataType::IntegerUnsigned(zerofill) => {
|
||||
DataType::UnsignedInteger(zerofill) => {
|
||||
format_type_with_optional_length(f, "INTEGER", zerofill, true)
|
||||
}
|
||||
DataType::BigInt(zerofill) => {
|
||||
format_type_with_optional_length(f, "BIGINT", zerofill, false)
|
||||
}
|
||||
DataType::BigIntUnsigned(zerofill) => {
|
||||
DataType::UnsignedBigInt(zerofill) => {
|
||||
format_type_with_optional_length(f, "BIGINT", zerofill, true)
|
||||
}
|
||||
DataType::Int8Unsigned(zerofill) => {
|
||||
DataType::UnsignedInt8(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")
|
||||
}
|
||||
|
|
@ -594,23 +453,11 @@ 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"),
|
||||
DataType::Float64 => write!(f, "FLOAT64"),
|
||||
DataType::Double(info) => write!(f, "DOUBLE{info}"),
|
||||
DataType::Double => write!(f, "DOUBLE"),
|
||||
DataType::Float8 => write!(f, "FLOAT8"),
|
||||
DataType::DoublePrecision => write!(f, "DOUBLE PRECISION"),
|
||||
DataType::Bool => write!(f, "BOOL"),
|
||||
|
|
@ -626,7 +473,6 @@ 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,
|
||||
|
|
@ -640,16 +486,8 @@ impl fmt::Display for DataType {
|
|||
DataType::JSONB => write!(f, "JSONB"),
|
||||
DataType::Regclass => write!(f, "REGCLASS"),
|
||||
DataType::Text => write!(f, "TEXT"),
|
||||
DataType::TinyText => write!(f, "TINYTEXT"),
|
||||
DataType::MediumText => write!(f, "MEDIUMTEXT"),
|
||||
DataType::LongText => write!(f, "LONGTEXT"),
|
||||
DataType::String(size) => format_type_with_optional_length(f, "STRING", size, false),
|
||||
DataType::Bytea => write!(f, "BYTEA"),
|
||||
DataType::Bit(size) => format_type_with_optional_length(f, "BIT", size, false),
|
||||
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}[]"),
|
||||
|
|
@ -664,24 +502,13 @@ impl fmt::Display for DataType {
|
|||
write!(f, "{}({})", ty, modifiers.join(", "))
|
||||
}
|
||||
}
|
||||
DataType::Enum(vals, bits) => {
|
||||
match bits {
|
||||
Some(bits) => write!(f, "ENUM{bits}"),
|
||||
None => write!(f, "ENUM"),
|
||||
}?;
|
||||
write!(f, "(")?;
|
||||
DataType::Enum(vals) => {
|
||||
write!(f, "ENUM(")?;
|
||||
for (i, v) in vals.iter().enumerate() {
|
||||
if i != 0 {
|
||||
write!(f, ", ")?;
|
||||
}
|
||||
match v {
|
||||
EnumMember::Name(name) => {
|
||||
write!(f, "'{}'", escape_single_quote_string(name))?
|
||||
}
|
||||
EnumMember::NamedValue(name, value) => {
|
||||
write!(f, "'{}' = {}", escape_single_quote_string(name), value)?
|
||||
}
|
||||
}
|
||||
write!(f, "'{}'", escape_single_quote_string(v))?;
|
||||
}
|
||||
write!(f, ")")
|
||||
}
|
||||
|
|
@ -714,16 +541,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))
|
||||
|
|
@ -733,21 +560,6 @@ 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"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -780,18 +592,6 @@ 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,
|
||||
|
|
@ -849,19 +649,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, [SQL Standard], [Oracle]
|
||||
/// Temporal type 'WITH TIME ZONE'. E.g., TIMESTAMP WITH TIME ZONE, [standard], [Oracle]
|
||||
///
|
||||
/// [SQL Standard]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#datetime-type
|
||||
/// [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, [SQL Standard], [Postgresql]
|
||||
/// Temporal type 'WITHOUT TIME ZONE'. E.g., TIME WITHOUT TIME ZONE, [standard], [Postgresql]
|
||||
///
|
||||
/// [SQL Standard]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#datetime-type
|
||||
/// [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,
|
||||
|
|
@ -890,18 +690,18 @@ impl fmt::Display for TimezoneInfo {
|
|||
}
|
||||
|
||||
/// Additional information for `NUMERIC`, `DECIMAL`, and `DEC` data types
|
||||
/// following the 2016 [SQL Standard].
|
||||
/// following the 2016 [standard].
|
||||
///
|
||||
/// [SQL Standard]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#exact-numeric-type
|
||||
/// [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),
|
||||
}
|
||||
|
||||
|
|
@ -942,7 +742,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}")?;
|
||||
}
|
||||
|
|
@ -955,7 +755,7 @@ impl fmt::Display for CharacterLength {
|
|||
}
|
||||
}
|
||||
|
||||
/// Possible units for characters, initially based on 2016 ANSI [SQL Standard][1].
|
||||
/// Possible units for characters, initially based on 2016 ANSI [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)]
|
||||
|
|
@ -981,32 +781,6 @@ 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.
|
||||
///
|
||||
|
|
@ -1024,34 +798,3 @@ 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"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -28,7 +28,7 @@ use serde::{Deserialize, Serialize};
|
|||
#[cfg(feature = "visitor")]
|
||||
use sqlparser_derive::{Visit, VisitMut};
|
||||
|
||||
use super::{display_comma_separated, Expr, Ident, Password};
|
||||
use super::{Expr, Ident, Password};
|
||||
use crate::ast::{display_separated, ObjectName};
|
||||
|
||||
/// An option in `ROLE` statement.
|
||||
|
|
@ -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 {
|
||||
|
|
@ -204,51 +204,24 @@ impl fmt::Display for AlterRoleOperation {
|
|||
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
|
||||
#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
|
||||
pub enum Use {
|
||||
Catalog(ObjectName), // e.g. `USE CATALOG foo.bar`
|
||||
Schema(ObjectName), // e.g. `USE SCHEMA foo.bar`
|
||||
Database(ObjectName), // e.g. `USE DATABASE foo.bar`
|
||||
Warehouse(ObjectName), // e.g. `USE WAREHOUSE foo.bar`
|
||||
Role(ObjectName), // e.g. `USE ROLE PUBLIC`
|
||||
SecondaryRoles(SecondaryRoles), // e.g. `USE SECONDARY ROLES ALL`
|
||||
Object(ObjectName), // e.g. `USE foo.bar`
|
||||
Default, // e.g. `USE DEFAULT`
|
||||
Catalog(ObjectName), // e.g. `USE CATALOG foo.bar`
|
||||
Schema(ObjectName), // e.g. `USE SCHEMA foo.bar`
|
||||
Database(ObjectName), // e.g. `USE DATABASE foo.bar`
|
||||
Warehouse(ObjectName), // e.g. `USE WAREHOUSE foo.bar`
|
||||
Object(ObjectName), // e.g. `USE foo.bar`
|
||||
Default, // e.g. `USE DEFAULT`
|
||||
}
|
||||
|
||||
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::SecondaryRoles(secondary_roles) => {
|
||||
write!(f, "SECONDARY ROLES {secondary_roles}")
|
||||
}
|
||||
Use::Object(name) => write!(f, "{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::Object(name) => write!(f, "{}", name),
|
||||
Use::Default => write!(f, "DEFAULT"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Snowflake `SECONDARY ROLES` USE variant
|
||||
/// See: <https://docs.snowflake.com/en/sql-reference/sql/use-secondary-roles>
|
||||
#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
|
||||
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
|
||||
#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
|
||||
pub enum SecondaryRoles {
|
||||
All,
|
||||
None,
|
||||
List(Vec<Ident>),
|
||||
}
|
||||
|
||||
impl fmt::Display for SecondaryRoles {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
match self {
|
||||
SecondaryRoles::All => write!(f, "ALL"),
|
||||
SecondaryRoles::None => write!(f, "NONE"),
|
||||
SecondaryRoles::List(roles) => write!(f, "{}", display_comma_separated(roles)),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
864
src/ast/ddl.rs
864
src/ast/ddl.rs
File diff suppressed because it is too large
Load diff
258
src/ast/dml.rs
258
src/ast/dml.rs
|
|
@ -29,38 +29,16 @@ 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, 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,
|
||||
display_comma_separated, display_separated, ClusteredBy, CommentDef, Expr, FileFormat,
|
||||
FromTable, HiveDistributionStyle, HiveFormat, HiveIOFormat, HiveRowFormat, Ident,
|
||||
InsertAliases, MysqlInsertPriority, ObjectName, OnCommit, OnInsert, OneOrManyWithParens,
|
||||
OrderByExpr, Query, RowAccessPolicy, SelectItem, SqlOption, SqliteOnConflict, TableEngine,
|
||||
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))]
|
||||
|
|
@ -70,8 +48,8 @@ pub struct CreateIndex {
|
|||
pub name: Option<ObjectName>,
|
||||
#[cfg_attr(feature = "visitor", visit(with = "visit_relation"))]
|
||||
pub table_name: ObjectName,
|
||||
pub using: Option<IndexType>,
|
||||
pub columns: Vec<IndexColumn>,
|
||||
pub using: Option<Ident>,
|
||||
pub columns: Vec<OrderByExpr>,
|
||||
pub unique: bool,
|
||||
pub concurrently: bool,
|
||||
pub if_not_exists: bool,
|
||||
|
|
@ -139,7 +117,6 @@ 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,
|
||||
|
|
@ -148,17 +125,19 @@ pub struct CreateTable {
|
|||
pub constraints: Vec<TableConstraint>,
|
||||
pub hive_distribution: HiveDistributionStyle,
|
||||
pub hive_formats: Option<HiveFormat>,
|
||||
pub table_options: CreateTableOptions,
|
||||
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>,
|
||||
// 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 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>,
|
||||
/// ClickHouse "ON CLUSTER" clause:
|
||||
/// <https://clickhouse.com/docs/en/sql-reference/distributed-ddl/>
|
||||
|
|
@ -175,17 +154,13 @@ 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>
|
||||
/// 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>>>,
|
||||
pub cluster_by: Option<WrappedCollection<Vec<Ident>>>,
|
||||
/// Hive: Table clustering column list.
|
||||
/// <https://cwiki.apache.org/confluence/display/Hive/LanguageManual+DDL#LanguageManualDDL-CreateTable>
|
||||
pub clustered_by: Option<ClusteredBy>,
|
||||
/// 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>>,
|
||||
/// BigQuery: Table options list.
|
||||
/// <https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language#table_option_list>
|
||||
pub options: Option<Vec<SqlOption>>,
|
||||
/// 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.
|
||||
|
|
@ -217,21 +192,6 @@ 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 {
|
||||
|
|
@ -245,7 +205,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}{iceberg}TABLE {if_not_exists}{name}",
|
||||
"CREATE {or_replace}{external}{global}{temporary}{transient}{volatile}TABLE {if_not_exists}{name}",
|
||||
or_replace = if self.or_replace { "OR REPLACE " } else { "" },
|
||||
external = if self.external { "EXTERNAL " } else { "" },
|
||||
global = self.global
|
||||
|
|
@ -261,32 +221,25 @@ 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() {
|
||||
f.write_str(" (")?;
|
||||
NewLine.fmt(f)?;
|
||||
Indent(DisplayCommaSeparated(&self.columns)).fmt(f)?;
|
||||
write!(f, " ({}", display_comma_separated(&self.columns))?;
|
||||
if !self.columns.is_empty() && !self.constraints.is_empty() {
|
||||
f.write_str(",")?;
|
||||
SpaceOrNewline.fmt(f)?;
|
||||
write!(f, ", ")?;
|
||||
}
|
||||
Indent(DisplayCommaSeparated(&self.constraints)).fmt(f)?;
|
||||
NewLine.fmt(f)?;
|
||||
f.write_str(")")?;
|
||||
write!(f, "{})", display_comma_separated(&self.constraints))?;
|
||||
} else if self.query.is_none() && self.like.is_none() && self.clone.is_none() {
|
||||
// PostgreSQL allows `CREATE TABLE t ();`, but requires empty parens
|
||||
f.write_str(" ()")?;
|
||||
write!(f, " ()")?;
|
||||
}
|
||||
|
||||
// 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(comment) = &self.comment {
|
||||
if let Some(CommentDef::AfterColumnDefsWithoutEq(comment)) = &self.comment {
|
||||
write!(f, " COMMENT '{comment}'")?;
|
||||
}
|
||||
|
||||
|
|
@ -379,22 +332,40 @@ impl Display for CreateTable {
|
|||
}
|
||||
write!(f, " LOCATION '{}'", self.location.as_ref().unwrap())?;
|
||||
}
|
||||
|
||||
match &self.table_options {
|
||||
options @ CreateTableOptions::With(_)
|
||||
| options @ CreateTableOptions::Plain(_)
|
||||
| options @ CreateTableOptions::TableProperties(_) => write!(f, " {options}")?,
|
||||
_ => (),
|
||||
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(_) => (),
|
||||
}
|
||||
}
|
||||
|
||||
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}")?;
|
||||
}
|
||||
if let Some(inherits) = &self.inherits {
|
||||
write!(f, " INHERITS ({})", display_comma_separated(inherits))?;
|
||||
write!(f, " ORDER BY {}", order_by)?;
|
||||
}
|
||||
if let Some(partition_by) = self.partition_by.as_ref() {
|
||||
write!(f, " PARTITION BY {partition_by}")?;
|
||||
|
|
@ -402,31 +373,12 @@ 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(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() {
|
||||
if let Some(options) = self.options.as_ref() {
|
||||
write!(
|
||||
f,
|
||||
" STORAGE_SERIALIZATION_POLICY = {storage_serialization_policy}"
|
||||
" OPTIONS({})",
|
||||
display_comma_separated(options.as_slice())
|
||||
)?;
|
||||
}
|
||||
|
||||
|
|
@ -480,6 +432,13 @@ 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",
|
||||
|
|
@ -511,7 +470,8 @@ pub struct Insert {
|
|||
/// INTO - optional keyword
|
||||
pub into: bool,
|
||||
/// TABLE
|
||||
pub table: TableObject,
|
||||
#[cfg_attr(feature = "visitor", visit(with = "visit_relation"))]
|
||||
pub table_name: ObjectName,
|
||||
/// table_name as foo (for PostgreSQL)
|
||||
pub table_alias: Option<Ident>,
|
||||
/// COLUMNS
|
||||
|
|
@ -520,15 +480,12 @@ pub struct Insert {
|
|||
pub overwrite: bool,
|
||||
/// A SQL query that specifies what to insert
|
||||
pub source: Option<Box<Query>>,
|
||||
/// MySQL `INSERT INTO ... SET`
|
||||
/// See: <https://dev.mysql.com/doc/refman/8.4/en/insert.html>
|
||||
pub assignments: Vec<Assignment>,
|
||||
/// partitioned insert (Hive)
|
||||
pub partitioned: Option<Vec<Expr>>,
|
||||
/// Columns defined after PARTITION
|
||||
pub after_columns: Vec<Ident>,
|
||||
/// whether the insert has the table keyword (Hive)
|
||||
pub has_table_keyword: bool,
|
||||
pub table: bool,
|
||||
pub on: Option<OnInsert>,
|
||||
/// RETURNING
|
||||
pub returning: Option<Vec<SelectItem>>,
|
||||
|
|
@ -538,31 +495,18 @@ pub struct Insert {
|
|||
pub priority: Option<MysqlInsertPriority>,
|
||||
/// Only for mysql
|
||||
pub insert_alias: Option<InsertAliases>,
|
||||
/// Settings used for ClickHouse.
|
||||
///
|
||||
/// ClickHouse syntax: `INSERT INTO tbl SETTINGS format_template_resultset = '/some/path/resultset.format'`
|
||||
///
|
||||
/// [ClickHouse `INSERT INTO`](https://clickhouse.com/docs/en/sql-reference/statements/insert-into)
|
||||
pub settings: Option<Vec<Setting>>,
|
||||
/// Format for `INSERT` statement when not using standard SQL format. Can be e.g. `CSV`,
|
||||
/// `JSON`, `JSONAsString`, `LineAsString` and more.
|
||||
///
|
||||
/// ClickHouse syntax: `INSERT INTO tbl FORMAT JSONEachRow {"foo": 1, "bar": 2}, {"foo": 3}`
|
||||
///
|
||||
/// [ClickHouse formats JSON insert](https://clickhouse.com/docs/en/interfaces/formats#json-inserting-data)
|
||||
pub format_clause: Option<InputFormatClause>,
|
||||
}
|
||||
|
||||
impl Display for Insert {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
let table_name = if let Some(alias) = &self.table_alias {
|
||||
format!("{0} AS {alias}", self.table)
|
||||
format!("{0} AS {alias}", self.table_name)
|
||||
} else {
|
||||
self.table.to_string()
|
||||
self.table_name.to_string()
|
||||
};
|
||||
|
||||
if let Some(on_conflict) = self.or {
|
||||
write!(f, "INSERT {on_conflict} INTO {table_name} ")?;
|
||||
if let Some(action) = self.or {
|
||||
write!(f, "INSERT OR {action} INTO {table_name} ")?;
|
||||
} else {
|
||||
write!(
|
||||
f,
|
||||
|
|
@ -584,37 +528,26 @@ impl Display for Insert {
|
|||
ignore = if self.ignore { " IGNORE" } else { "" },
|
||||
over = if self.overwrite { " OVERWRITE" } else { "" },
|
||||
int = if self.into { " INTO" } else { "" },
|
||||
tbl = if self.has_table_keyword { " TABLE" } else { "" },
|
||||
tbl = if self.table { " TABLE" } else { "" },
|
||||
)?;
|
||||
}
|
||||
if !self.columns.is_empty() {
|
||||
write!(f, "({})", display_comma_separated(&self.columns))?;
|
||||
SpaceOrNewline.fmt(f)?;
|
||||
write!(f, "({}) ", display_comma_separated(&self.columns))?;
|
||||
}
|
||||
if let Some(ref parts) = self.partitioned {
|
||||
if !parts.is_empty() {
|
||||
write!(f, "PARTITION ({})", display_comma_separated(parts))?;
|
||||
SpaceOrNewline.fmt(f)?;
|
||||
write!(f, "PARTITION ({}) ", display_comma_separated(parts))?;
|
||||
}
|
||||
}
|
||||
if !self.after_columns.is_empty() {
|
||||
write!(f, "({})", display_comma_separated(&self.after_columns))?;
|
||||
SpaceOrNewline.fmt(f)?;
|
||||
}
|
||||
|
||||
if let Some(settings) = &self.settings {
|
||||
write!(f, "SETTINGS {}", display_comma_separated(settings))?;
|
||||
SpaceOrNewline.fmt(f)?;
|
||||
write!(f, "({}) ", display_comma_separated(&self.after_columns))?;
|
||||
}
|
||||
|
||||
if let Some(source) = &self.source {
|
||||
source.fmt(f)?;
|
||||
} else if !self.assignments.is_empty() {
|
||||
write!(f, "SET")?;
|
||||
indented_list(f, &self.assignments)?;
|
||||
} else if let Some(format_clause) = &self.format_clause {
|
||||
format_clause.fmt(f)?;
|
||||
} else if self.columns.is_empty() {
|
||||
write!(f, "{source}")?;
|
||||
}
|
||||
|
||||
if self.source.is_none() && self.columns.is_empty() {
|
||||
write!(f, "DEFAULT VALUES")?;
|
||||
}
|
||||
|
||||
|
|
@ -633,9 +566,7 @@ impl Display for Insert {
|
|||
}
|
||||
|
||||
if let Some(returning) = &self.returning {
|
||||
SpaceOrNewline.fmt(f)?;
|
||||
f.write_str("RETURNING")?;
|
||||
indented_list(f, returning)?;
|
||||
write!(f, " RETURNING {}", display_comma_separated(returning))?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
|
@ -664,45 +595,32 @@ pub struct Delete {
|
|||
|
||||
impl Display for Delete {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
f.write_str("DELETE")?;
|
||||
write!(f, "DELETE ")?;
|
||||
if !self.tables.is_empty() {
|
||||
indented_list(f, &self.tables)?;
|
||||
write!(f, "{} ", display_comma_separated(&self.tables))?;
|
||||
}
|
||||
match &self.from {
|
||||
FromTable::WithFromKeyword(from) => {
|
||||
f.write_str(" FROM")?;
|
||||
indented_list(f, from)?;
|
||||
write!(f, "FROM {}", display_comma_separated(from))?;
|
||||
}
|
||||
FromTable::WithoutKeyword(from) => {
|
||||
indented_list(f, from)?;
|
||||
write!(f, "{}", display_comma_separated(from))?;
|
||||
}
|
||||
}
|
||||
if let Some(using) = &self.using {
|
||||
SpaceOrNewline.fmt(f)?;
|
||||
f.write_str("USING")?;
|
||||
indented_list(f, using)?;
|
||||
write!(f, " USING {}", display_comma_separated(using))?;
|
||||
}
|
||||
if let Some(selection) = &self.selection {
|
||||
SpaceOrNewline.fmt(f)?;
|
||||
f.write_str("WHERE")?;
|
||||
SpaceOrNewline.fmt(f)?;
|
||||
Indent(selection).fmt(f)?;
|
||||
write!(f, " WHERE {selection}")?;
|
||||
}
|
||||
if let Some(returning) = &self.returning {
|
||||
SpaceOrNewline.fmt(f)?;
|
||||
f.write_str("RETURNING")?;
|
||||
indented_list(f, returning)?;
|
||||
write!(f, " RETURNING {}", display_comma_separated(returning))?;
|
||||
}
|
||||
if !self.order_by.is_empty() {
|
||||
SpaceOrNewline.fmt(f)?;
|
||||
f.write_str("ORDER BY")?;
|
||||
indented_list(f, &self.order_by)?;
|
||||
write!(f, " ORDER BY {}", display_comma_separated(&self.order_by))?;
|
||||
}
|
||||
if let Some(limit) = &self.limit {
|
||||
SpaceOrNewline.fmt(f)?;
|
||||
f.write_str("LIMIT")?;
|
||||
SpaceOrNewline.fmt(f)?;
|
||||
Indent(limit).fmt(f)?;
|
||||
write!(f, " LIMIT {limit}")?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,136 +0,0 @@
|
|||
// 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 core::cmp::{Eq, Ord, Ordering, PartialEq, PartialOrd};
|
||||
use core::fmt::{self, Debug, Formatter};
|
||||
use core::hash::{Hash, Hasher};
|
||||
|
||||
use crate::tokenizer::TokenWithSpan;
|
||||
|
||||
#[cfg(feature = "serde")]
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
#[cfg(feature = "visitor")]
|
||||
use sqlparser_derive::{Visit, VisitMut};
|
||||
|
||||
/// A wrapper over [`TokenWithSpan`]s that ignores the token and source
|
||||
/// location in comparisons and hashing.
|
||||
///
|
||||
/// This type is used when the token and location is not relevant for semantics,
|
||||
/// but is still needed for accurate source location tracking, for example, in
|
||||
/// the nodes in the [ast](crate::ast) module.
|
||||
///
|
||||
/// Note: **All** `AttachedTokens` are equal.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// Same token, different location are equal
|
||||
/// ```
|
||||
/// # use sqlparser::ast::helpers::attached_token::AttachedToken;
|
||||
/// # use sqlparser::tokenizer::{Location, Span, Token, TokenWithLocation};
|
||||
/// // commas @ line 1, column 10
|
||||
/// let tok1 = TokenWithLocation::new(
|
||||
/// Token::Comma,
|
||||
/// Span::new(Location::new(1, 10), Location::new(1, 11)),
|
||||
/// );
|
||||
/// // commas @ line 2, column 20
|
||||
/// let tok2 = TokenWithLocation::new(
|
||||
/// Token::Comma,
|
||||
/// Span::new(Location::new(2, 20), Location::new(2, 21)),
|
||||
/// );
|
||||
///
|
||||
/// assert_ne!(tok1, tok2); // token with locations are *not* equal
|
||||
/// assert_eq!(AttachedToken(tok1), AttachedToken(tok2)); // attached tokens are
|
||||
/// ```
|
||||
///
|
||||
/// Different token, different location are equal 🤯
|
||||
///
|
||||
/// ```
|
||||
/// # use sqlparser::ast::helpers::attached_token::AttachedToken;
|
||||
/// # use sqlparser::tokenizer::{Location, Span, Token, TokenWithLocation};
|
||||
/// // commas @ line 1, column 10
|
||||
/// let tok1 = TokenWithLocation::new(
|
||||
/// Token::Comma,
|
||||
/// Span::new(Location::new(1, 10), Location::new(1, 11)),
|
||||
/// );
|
||||
/// // period @ line 2, column 20
|
||||
/// let tok2 = TokenWithLocation::new(
|
||||
/// Token::Period,
|
||||
/// Span::new(Location::new(2, 10), Location::new(2, 21)),
|
||||
/// );
|
||||
///
|
||||
/// assert_ne!(tok1, tok2); // token with locations are *not* equal
|
||||
/// assert_eq!(AttachedToken(tok1), AttachedToken(tok2)); // attached tokens are
|
||||
/// ```
|
||||
/// // period @ line 2, column 20
|
||||
#[derive(Clone)]
|
||||
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
|
||||
#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
|
||||
pub struct AttachedToken(pub TokenWithSpan);
|
||||
|
||||
impl AttachedToken {
|
||||
/// Return a new Empty AttachedToken
|
||||
pub fn empty() -> Self {
|
||||
AttachedToken(TokenWithSpan::new_eof())
|
||||
}
|
||||
}
|
||||
|
||||
// Conditional Implementations
|
||||
impl Debug for AttachedToken {
|
||||
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
|
||||
self.0.fmt(f)
|
||||
}
|
||||
}
|
||||
|
||||
// Blanket Implementations
|
||||
impl PartialEq for AttachedToken {
|
||||
fn eq(&self, _: &Self) -> bool {
|
||||
true
|
||||
}
|
||||
}
|
||||
|
||||
impl Eq for AttachedToken {}
|
||||
|
||||
impl PartialOrd for AttachedToken {
|
||||
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
|
||||
Some(self.cmp(other))
|
||||
}
|
||||
}
|
||||
|
||||
impl Ord for AttachedToken {
|
||||
fn cmp(&self, _: &Self) -> Ordering {
|
||||
Ordering::Equal
|
||||
}
|
||||
}
|
||||
|
||||
impl Hash for AttachedToken {
|
||||
fn hash<H: Hasher>(&self, _state: &mut H) {
|
||||
// Do nothing
|
||||
}
|
||||
}
|
||||
|
||||
impl From<TokenWithSpan> for AttachedToken {
|
||||
fn from(value: TokenWithSpan) -> Self {
|
||||
AttachedToken(value)
|
||||
}
|
||||
}
|
||||
|
||||
impl From<AttachedToken> for TokenWithSpan {
|
||||
fn from(value: AttachedToken) -> Self {
|
||||
value.0
|
||||
}
|
||||
}
|
||||
|
|
@ -1,89 +0,0 @@
|
|||
// 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(())
|
||||
}
|
||||
}
|
||||
|
|
@ -14,7 +14,5 @@
|
|||
// KIND, either express or implied. See the License for the
|
||||
// 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;
|
||||
|
|
|
|||
|
|
@ -26,12 +26,10 @@ use sqlparser_derive::{Visit, VisitMut};
|
|||
|
||||
use super::super::dml::CreateTable;
|
||||
use crate::ast::{
|
||||
ClusteredBy, ColumnDef, CommentDef, CreateTableOptions, Expr, FileFormat,
|
||||
HiveDistributionStyle, HiveFormat, Ident, ObjectName, OnCommit, OneOrManyWithParens, Query,
|
||||
RowAccessPolicy, Statement, StorageSerializationPolicy, TableConstraint, Tag,
|
||||
WrappedCollection,
|
||||
ClusteredBy, ColumnDef, CommentDef, Expr, FileFormat, HiveDistributionStyle, HiveFormat, Ident,
|
||||
ObjectName, OnCommit, OneOrManyWithParens, Query, RowAccessPolicy, SqlOption, Statement,
|
||||
TableConstraint, TableEngine, Tag, WrappedCollection,
|
||||
};
|
||||
|
||||
use crate::parser::ParserError;
|
||||
|
||||
/// Builder for create table statement variant ([1]).
|
||||
|
|
@ -44,11 +42,12 @@ 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::from(vec![Ident::new("table_name")]))
|
||||
/// let builder = CreateTableBuilder::new(ObjectName(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
|
||||
|
|
@ -72,27 +71,32 @@ 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<Expr>>>,
|
||||
pub cluster_by: Option<WrappedCollection<Vec<Ident>>>,
|
||||
pub clustered_by: Option<ClusteredBy>,
|
||||
pub inherits: Option<Vec<ObjectName>>,
|
||||
pub options: Option<Vec<SqlOption>>,
|
||||
pub strict: bool,
|
||||
pub copy_grants: bool,
|
||||
pub enable_schema_evolution: Option<bool>,
|
||||
|
|
@ -103,12 +107,6 @@ 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 {
|
||||
|
|
@ -121,19 +119,24 @@ 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,
|
||||
|
|
@ -141,7 +144,7 @@ impl CreateTableBuilder {
|
|||
partition_by: None,
|
||||
cluster_by: None,
|
||||
clustered_by: None,
|
||||
inherits: None,
|
||||
options: None,
|
||||
strict: false,
|
||||
copy_grants: false,
|
||||
enable_schema_evolution: None,
|
||||
|
|
@ -152,12 +155,6 @@ 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 {
|
||||
|
|
@ -195,11 +192,6 @@ 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
|
||||
|
|
@ -220,6 +212,15 @@ 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
|
||||
|
|
@ -249,11 +250,31 @@ impl CreateTableBuilder {
|
|||
self
|
||||
}
|
||||
|
||||
pub fn comment_after_column_def(mut self, comment: Option<CommentDef>) -> Self {
|
||||
pub fn engine(mut self, engine: Option<TableEngine>) -> Self {
|
||||
self.engine = engine;
|
||||
self
|
||||
}
|
||||
|
||||
pub fn comment(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
|
||||
|
|
@ -279,7 +300,7 @@ impl CreateTableBuilder {
|
|||
self
|
||||
}
|
||||
|
||||
pub fn cluster_by(mut self, cluster_by: Option<WrappedCollection<Vec<Expr>>>) -> Self {
|
||||
pub fn cluster_by(mut self, cluster_by: Option<WrappedCollection<Vec<Ident>>>) -> Self {
|
||||
self.cluster_by = cluster_by;
|
||||
self
|
||||
}
|
||||
|
|
@ -289,8 +310,8 @@ impl CreateTableBuilder {
|
|||
self
|
||||
}
|
||||
|
||||
pub fn inherits(mut self, inherits: Option<Vec<ObjectName>>) -> Self {
|
||||
self.inherits = inherits;
|
||||
pub fn options(mut self, options: Option<Vec<SqlOption>>) -> Self {
|
||||
self.options = options;
|
||||
self
|
||||
}
|
||||
|
||||
|
|
@ -350,39 +371,6 @@ 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,
|
||||
|
|
@ -392,19 +380,24 @@ 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,
|
||||
|
|
@ -412,7 +405,7 @@ impl CreateTableBuilder {
|
|||
partition_by: self.partition_by,
|
||||
cluster_by: self.cluster_by,
|
||||
clustered_by: self.clustered_by,
|
||||
inherits: self.inherits,
|
||||
options: self.options,
|
||||
strict: self.strict,
|
||||
copy_grants: self.copy_grants,
|
||||
enable_schema_evolution: self.enable_schema_evolution,
|
||||
|
|
@ -423,12 +416,6 @@ 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,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
|
@ -448,19 +435,24 @@ 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,
|
||||
|
|
@ -468,7 +460,7 @@ impl TryFrom<Statement> for CreateTableBuilder {
|
|||
partition_by,
|
||||
cluster_by,
|
||||
clustered_by,
|
||||
inherits,
|
||||
options,
|
||||
strict,
|
||||
copy_grants,
|
||||
enable_schema_evolution,
|
||||
|
|
@ -479,12 +471,6 @@ 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,
|
||||
|
|
@ -497,13 +483,19 @@ 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,
|
||||
|
|
@ -511,9 +503,8 @@ impl TryFrom<Statement> for CreateTableBuilder {
|
|||
partition_by,
|
||||
cluster_by,
|
||||
clustered_by,
|
||||
inherits,
|
||||
options,
|
||||
strict,
|
||||
iceberg,
|
||||
copy_grants,
|
||||
enable_schema_evolution,
|
||||
change_tracking,
|
||||
|
|
@ -524,12 +515,6 @@ 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}"
|
||||
|
|
@ -542,9 +527,8 @@ impl TryFrom<Statement> for CreateTableBuilder {
|
|||
#[derive(Default)]
|
||||
pub(crate) struct CreateTableConfiguration {
|
||||
pub partition_by: Option<Box<Expr>>,
|
||||
pub cluster_by: Option<WrappedCollection<Vec<Expr>>>,
|
||||
pub inherits: Option<Vec<ObjectName>>,
|
||||
pub table_options: CreateTableOptions,
|
||||
pub cluster_by: Option<WrappedCollection<Vec<Ident>>>,
|
||||
pub options: Option<Vec<SqlOption>>,
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
|
|
@ -555,7 +539,7 @@ mod tests {
|
|||
|
||||
#[test]
|
||||
pub fn test_from_valid_statement() {
|
||||
let builder = CreateTableBuilder::new(ObjectName::from(vec![Ident::new("table_name")]));
|
||||
let builder = CreateTableBuilder::new(ObjectName(vec![Ident::new("table_name")]));
|
||||
|
||||
let stmt = builder.clone().build();
|
||||
|
||||
|
|
@ -564,11 +548,7 @@ mod tests {
|
|||
|
||||
#[test]
|
||||
pub fn test_from_invalid_statement() {
|
||||
let stmt = Statement::Commit {
|
||||
chain: false,
|
||||
end: false,
|
||||
modifier: None,
|
||||
};
|
||||
let stmt = Statement::Commit { chain: false };
|
||||
|
||||
assert_eq!(
|
||||
CreateTableBuilder::try_from(stmt).unwrap_err(),
|
||||
|
|
|
|||
|
|
@ -21,13 +21,15 @@
|
|||
|
||||
#[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::helpers::key_value_options::KeyValueOptions;
|
||||
use crate::ast::{Ident, ObjectName, SelectItem};
|
||||
use crate::ast::Ident;
|
||||
#[cfg(feature = "visitor")]
|
||||
use sqlparser_derive::{Visit, VisitMut};
|
||||
|
||||
|
|
@ -36,29 +38,35 @@ use sqlparser_derive::{Visit, VisitMut};
|
|||
#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
|
||||
pub struct StageParamsObject {
|
||||
pub url: Option<String>,
|
||||
pub encryption: KeyValueOptions,
|
||||
pub encryption: DataLoadingOptions,
|
||||
pub endpoint: Option<String>,
|
||||
pub storage_integration: Option<String>,
|
||||
pub credentials: KeyValueOptions,
|
||||
pub credentials: DataLoadingOptions,
|
||||
}
|
||||
|
||||
/// 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 enum StageLoadSelectItemKind {
|
||||
SelectItem(SelectItem),
|
||||
StageLoadSelectItem(StageLoadSelectItem),
|
||||
pub struct DataLoadingOptions {
|
||||
pub options: Vec<DataLoadingOption>,
|
||||
}
|
||||
|
||||
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)]
|
||||
#[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,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
|
|
@ -97,6 +105,42 @@ 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() {
|
||||
|
|
@ -112,22 +156,3 @@ impl fmt::Display for StageLoadSelectItem {
|
|||
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 FileStagingCommand {
|
||||
#[cfg_attr(feature = "visitor", visit(with = "visit_relation"))]
|
||||
pub stage: ObjectName,
|
||||
pub pattern: Option<String>,
|
||||
}
|
||||
|
||||
impl fmt::Display for FileStagingCommand {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
write!(f, "{}", self.stage)?;
|
||||
if let Some(pattern) = self.pattern.as_ref() {
|
||||
write!(f, " PATTERN='{pattern}'")?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
|
|
|||
4072
src/ast/mod.rs
4072
src/ast/mod.rs
File diff suppressed because it is too large
Load diff
|
|
@ -51,23 +51,6 @@ pub enum UnaryOperator {
|
|||
PGPrefixFactorial,
|
||||
/// Absolute value, e.g. `@ -9` (PostgreSQL-specific)
|
||||
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 {
|
||||
|
|
@ -82,12 +65,6 @@ impl fmt::Display for UnaryOperator {
|
|||
UnaryOperator::PGPostfixFactorial => "!",
|
||||
UnaryOperator::PGPrefixFactorial => "!!",
|
||||
UnaryOperator::PGAbs => "@",
|
||||
UnaryOperator::BangNot => "!",
|
||||
UnaryOperator::Hash => "#",
|
||||
UnaryOperator::AtDashAt => "@-@",
|
||||
UnaryOperator::DoubleAt => "@@",
|
||||
UnaryOperator::QuestionDash => "?-",
|
||||
UnaryOperator::QuestionPipe => "?|",
|
||||
})
|
||||
}
|
||||
}
|
||||
|
|
@ -139,11 +116,6 @@ 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)
|
||||
|
|
@ -273,62 +245,6 @@ pub enum BinaryOperator {
|
|||
/// See [CREATE OPERATOR](https://www.postgresql.org/docs/current/sql-createoperator.html)
|
||||
/// for more information.
|
||||
PGCustomBinaryOperator(Vec<String>),
|
||||
/// The `OVERLAPS` operator
|
||||
///
|
||||
/// 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 {
|
||||
|
|
@ -355,8 +271,6 @@ 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("<<"),
|
||||
|
|
@ -387,24 +301,6 @@ impl fmt::Display for BinaryOperator {
|
|||
BinaryOperator::PGCustomBinaryOperator(idents) => {
|
||||
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(":="),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
1590
src/ast/query.rs
1590
src/ast/query.rs
File diff suppressed because it is too large
Load diff
2506
src/ast/spans.rs
2506
src/ast/spans.rs
File diff suppressed because it is too large
Load diff
|
|
@ -110,7 +110,6 @@ 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,
|
||||
|
|
@ -119,7 +118,6 @@ 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"),
|
||||
|
|
|
|||
214
src/ast/value.rs
214
src/ast/value.rs
|
|
@ -26,96 +26,14 @@ use bigdecimal::BigDecimal;
|
|||
#[cfg(feature = "serde")]
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use crate::{ast::Ident, tokenizer::Span};
|
||||
use crate::ast::Ident;
|
||||
#[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),
|
||||
visit(with = "visit_value")
|
||||
)]
|
||||
#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
|
||||
pub enum Value {
|
||||
/// Numeric literal
|
||||
#[cfg(not(feature = "bigdecimal"))]
|
||||
|
|
@ -179,53 +97,6 @@ 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 {
|
||||
|
|
@ -284,9 +155,7 @@ impl fmt::Display for DollarQuotedString {
|
|||
#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
|
||||
pub enum DateTimeField {
|
||||
Year,
|
||||
Years,
|
||||
Month,
|
||||
Months,
|
||||
/// Week optionally followed by a WEEKDAY.
|
||||
///
|
||||
/// ```sql
|
||||
|
|
@ -295,19 +164,14 @@ pub enum DateTimeField {
|
|||
///
|
||||
/// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/date_functions#extract)
|
||||
Week(Option<Ident>),
|
||||
Weeks,
|
||||
Day,
|
||||
DayOfWeek,
|
||||
DayOfYear,
|
||||
Days,
|
||||
Date,
|
||||
Datetime,
|
||||
Hour,
|
||||
Hours,
|
||||
Minute,
|
||||
Minutes,
|
||||
Second,
|
||||
Seconds,
|
||||
Century,
|
||||
Decade,
|
||||
Dow,
|
||||
|
|
@ -346,9 +210,7 @@ impl fmt::Display for DateTimeField {
|
|||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
match self {
|
||||
DateTimeField::Year => write!(f, "YEAR"),
|
||||
DateTimeField::Years => write!(f, "YEARS"),
|
||||
DateTimeField::Month => write!(f, "MONTH"),
|
||||
DateTimeField::Months => write!(f, "MONTHS"),
|
||||
DateTimeField::Week(week_day) => {
|
||||
write!(f, "WEEK")?;
|
||||
if let Some(week_day) = week_day {
|
||||
|
|
@ -356,19 +218,14 @@ impl fmt::Display for DateTimeField {
|
|||
}
|
||||
Ok(())
|
||||
}
|
||||
DateTimeField::Weeks => write!(f, "WEEKS"),
|
||||
DateTimeField::Day => write!(f, "DAY"),
|
||||
DateTimeField::DayOfWeek => write!(f, "DAYOFWEEK"),
|
||||
DateTimeField::DayOfYear => write!(f, "DAYOFYEAR"),
|
||||
DateTimeField::Days => write!(f, "DAYS"),
|
||||
DateTimeField::Date => write!(f, "DATE"),
|
||||
DateTimeField::Datetime => write!(f, "DATETIME"),
|
||||
DateTimeField::Hour => write!(f, "HOUR"),
|
||||
DateTimeField::Hours => write!(f, "HOURS"),
|
||||
DateTimeField::Minute => write!(f, "MINUTE"),
|
||||
DateTimeField::Minutes => write!(f, "MINUTES"),
|
||||
DateTimeField::Second => write!(f, "SECOND"),
|
||||
DateTimeField::Seconds => write!(f, "SECONDS"),
|
||||
DateTimeField::Century => write!(f, "CENTURY"),
|
||||
DateTimeField::Decade => write!(f, "DECADE"),
|
||||
DateTimeField::Dow => write!(f, "DOW"),
|
||||
|
|
@ -399,41 +256,12 @@ impl fmt::Display for DateTimeField {
|
|||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Ord, PartialOrd, Hash)]
|
||||
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
|
||||
#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
|
||||
/// The Unicode Standard defines four normalization forms, which are intended to eliminate
|
||||
/// certain distinctions between visually or functionally identical characters.
|
||||
///
|
||||
/// See [Unicode Normalization Forms](https://unicode.org/reports/tr15/) for details.
|
||||
pub enum NormalizationForm {
|
||||
/// Canonical Decomposition, followed by Canonical Composition.
|
||||
NFC,
|
||||
/// Canonical Decomposition.
|
||||
NFD,
|
||||
/// Compatibility Decomposition, followed by Canonical Composition.
|
||||
NFKC,
|
||||
/// Compatibility Decomposition.
|
||||
NFKD,
|
||||
}
|
||||
|
||||
impl fmt::Display for NormalizationForm {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
match self {
|
||||
NormalizationForm::NFC => write!(f, "NFC"),
|
||||
NormalizationForm::NFD => write!(f, "NFD"),
|
||||
NormalizationForm::NFKC => write!(f, "NFKC"),
|
||||
NormalizationForm::NFKD => write!(f, "NFKD"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub struct EscapeQuotedString<'a> {
|
||||
string: &'a str,
|
||||
quote: char,
|
||||
}
|
||||
|
||||
impl fmt::Display for EscapeQuotedString<'_> {
|
||||
impl<'a> fmt::Display for EscapeQuotedString<'a> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
// EscapeQuotedString doesn't know which mode of escape was
|
||||
// chosen by the user. So this code must to correctly display
|
||||
|
|
@ -455,38 +283,30 @@ 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 start_idx = 0;
|
||||
let mut peekable_chars = self.string.char_indices().peekable();
|
||||
while let Some(&(idx, ch)) = peekable_chars.peek() {
|
||||
let mut peekable_chars = self.string.chars().peekable();
|
||||
while let Some(&ch) = peekable_chars.peek() {
|
||||
match ch {
|
||||
char if char == quote => {
|
||||
if previous_char == '\\' {
|
||||
// the quote is already escaped with a backslash, skip
|
||||
write!(f, "{char}")?;
|
||||
peekable_chars.next();
|
||||
continue;
|
||||
}
|
||||
peekable_chars.next();
|
||||
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;
|
||||
}
|
||||
if peekable_chars.peek().map(|c| *c == quote).unwrap_or(false) {
|
||||
write!(f, "{char}{char}")?;
|
||||
peekable_chars.next();
|
||||
} else {
|
||||
write!(f, "{char}{char}")?;
|
||||
}
|
||||
}
|
||||
_ => {
|
||||
write!(f, "{ch}")?;
|
||||
peekable_chars.next();
|
||||
}
|
||||
}
|
||||
previous_char = ch;
|
||||
}
|
||||
f.write_str(&self.string[start_idx..])?;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
|
@ -505,7 +325,7 @@ pub fn escape_double_quote_string(s: &str) -> EscapeQuotedString<'_> {
|
|||
|
||||
pub struct EscapeEscapedStringLiteral<'a>(&'a str);
|
||||
|
||||
impl fmt::Display for EscapeEscapedStringLiteral<'_> {
|
||||
impl<'a> fmt::Display for EscapeEscapedStringLiteral<'a> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
for c in self.0.chars() {
|
||||
match c {
|
||||
|
|
@ -539,7 +359,7 @@ pub fn escape_escaped_string(s: &str) -> EscapeEscapedStringLiteral<'_> {
|
|||
|
||||
pub struct EscapeUnicodeStringLiteral<'a>(&'a str);
|
||||
|
||||
impl fmt::Display for EscapeUnicodeStringLiteral<'_> {
|
||||
impl<'a> fmt::Display for EscapeUnicodeStringLiteral<'a> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
for c in self.0.chars() {
|
||||
match c {
|
||||
|
|
@ -550,16 +370,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, "\\{codepoint:04X}")?;
|
||||
write!(f, "\\{:04X}", codepoint)?;
|
||||
} else {
|
||||
write!(f, "\\+{codepoint:06X}")?;
|
||||
write!(f, "\\+{:06X}", codepoint)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@
|
|||
|
||||
//! Recursive visitors for ast Nodes. See [`Visitor`] for more details.
|
||||
|
||||
use crate::ast::{Expr, ObjectName, Query, Statement, TableFactor, Value};
|
||||
use crate::ast::{Expr, ObjectName, Query, Statement, TableFactor};
|
||||
use core::ops::ControlFlow;
|
||||
|
||||
/// A type that can be visited by a [`Visitor`]. See [`Visitor`] for
|
||||
|
|
@ -233,16 +233,6 @@ 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.
|
||||
|
|
@ -347,16 +337,6 @@ 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);
|
||||
|
|
@ -423,7 +403,7 @@ where
|
|||
/// ```
|
||||
/// # use sqlparser::parser::Parser;
|
||||
/// # use sqlparser::dialect::GenericDialect;
|
||||
/// # use sqlparser::ast::{ObjectName, ObjectNamePart, Ident, visit_relations_mut};
|
||||
/// # use sqlparser::ast::{ObjectName, visit_relations_mut};
|
||||
/// # use core::ops::ControlFlow;
|
||||
/// let sql = "SELECT a FROM foo";
|
||||
/// let mut statements = Parser::parse_sql(&GenericDialect{}, sql)
|
||||
|
|
@ -431,7 +411,7 @@ where
|
|||
///
|
||||
/// // visit statements, renaming table foo to bar
|
||||
/// visit_relations_mut(&mut statements, |table| {
|
||||
/// table.0[0] = ObjectNamePart::Identifier(Ident::new("bar"));
|
||||
/// table.0[0].value = table.0[0].value.replace("foo", "bar");
|
||||
/// ControlFlow::<()>::Continue(())
|
||||
/// });
|
||||
///
|
||||
|
|
@ -523,7 +503,7 @@ where
|
|||
/// // Remove all select limits in sub-queries
|
||||
/// visit_expressions_mut(&mut statements, |expr| {
|
||||
/// if let Expr::Subquery(q) = expr {
|
||||
/// q.limit_clause = None;
|
||||
/// q.limit = None
|
||||
/// }
|
||||
/// ControlFlow::<()>::Continue(())
|
||||
/// });
|
||||
|
|
@ -547,10 +527,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::from(vec![Ident::new("f")]),
|
||||
/// uses_odbc_syntax: false,
|
||||
/// name: ObjectName(vec![Ident::new("f")]),
|
||||
/// args: FunctionArguments::List(FunctionArgumentList {
|
||||
/// duplicate_treatment: None,
|
||||
/// args: vec![FunctionArg::Unnamed(FunctionArgExpr::Expr(old_expr))],
|
||||
|
|
@ -647,7 +626,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_clause = None;
|
||||
/// q.limit = None
|
||||
/// }
|
||||
/// ControlFlow::<()>::Continue(())
|
||||
/// });
|
||||
|
|
@ -667,7 +646,6 @@ where
|
|||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::ast::Statement;
|
||||
use crate::dialect::GenericDialect;
|
||||
use crate::parser::Parser;
|
||||
use crate::tokenizer::Tokenizer;
|
||||
|
|
@ -741,7 +719,7 @@ mod tests {
|
|||
}
|
||||
}
|
||||
|
||||
fn do_visit<V: Visitor<Break = ()>>(sql: &str, visitor: &mut V) -> Statement {
|
||||
fn do_visit(sql: &str) -> Vec<String> {
|
||||
let dialect = GenericDialect {};
|
||||
let tokens = Tokenizer::new(&dialect, sql).tokenize().unwrap();
|
||||
let s = Parser::new(&dialect)
|
||||
|
|
@ -749,9 +727,9 @@ mod tests {
|
|||
.parse_statement()
|
||||
.unwrap();
|
||||
|
||||
let flow = s.visit(visitor);
|
||||
assert_eq!(flow, ControlFlow::Continue(()));
|
||||
s
|
||||
let mut visitor = TestVisitor::default();
|
||||
s.visit(&mut visitor);
|
||||
visitor.visited
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -898,113 +876,12 @@ mod tests {
|
|||
"POST: QUERY: SELECT * FROM monthly_sales PIVOT(SUM(a.amount) FOR a.MONTH IN ('JAN', 'FEB', 'MAR', 'APR')) AS p (c, d) ORDER BY EMPID",
|
||||
"POST: STATEMENT: SELECT * FROM monthly_sales PIVOT(SUM(a.amount) FOR a.MONTH IN ('JAN', 'FEB', 'MAR', 'APR')) AS p (c, d) ORDER BY EMPID",
|
||||
]
|
||||
),
|
||||
(
|
||||
"SHOW COLUMNS FROM t1",
|
||||
vec![
|
||||
"PRE: STATEMENT: SHOW COLUMNS FROM t1",
|
||||
"PRE: RELATION: t1",
|
||||
"POST: RELATION: t1",
|
||||
"POST: STATEMENT: SHOW COLUMNS FROM t1",
|
||||
],
|
||||
),
|
||||
)
|
||||
];
|
||||
for (sql, expected) in tests {
|
||||
let mut visitor = TestVisitor::default();
|
||||
let _ = do_visit(sql, &mut visitor);
|
||||
let actual: Vec<_> = visitor.visited.iter().map(|x| x.as_str()).collect();
|
||||
let actual = do_visit(sql);
|
||||
let actual: Vec<_> = actual.iter().map(|x| x.as_str()).collect();
|
||||
assert_eq!(actual, expected)
|
||||
}
|
||||
}
|
||||
|
||||
struct QuickVisitor; // [`TestVisitor`] is too slow to iterate over thousands of nodes
|
||||
|
||||
impl Visitor for QuickVisitor {
|
||||
type Break = ();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn overflow() {
|
||||
let cond = (0..1000)
|
||||
.map(|n| format!("X = {n}"))
|
||||
.collect::<Vec<_>>()
|
||||
.join(" OR ");
|
||||
let sql = format!("SELECT x where {cond}");
|
||||
|
||||
let dialect = GenericDialect {};
|
||||
let tokens = Tokenizer::new(&dialect, sql.as_str()).tokenize().unwrap();
|
||||
let s = Parser::new(&dialect)
|
||||
.with_tokens(tokens)
|
||||
.parse_statement()
|
||||
.unwrap();
|
||||
|
||||
let mut visitor = QuickVisitor {};
|
||||
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)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -15,45 +15,14 @@
|
|||
// 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 {
|
||||
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>
|
||||
// See https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#identifiers
|
||||
fn is_delimited_identifier_start(&self, ch: char) -> bool {
|
||||
ch == '`'
|
||||
}
|
||||
|
|
@ -62,16 +31,8 @@ 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 {
|
||||
|
|
@ -111,37 +72,4 @@ impl Dialect for BigQueryDialect {
|
|||
fn require_interval_qualifier(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
// See https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types#constructing_a_struct
|
||||
fn supports_struct_literal(&self) -> bool {
|
||||
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
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -50,48 +50,4 @@ impl Dialect for ClickHouseDialect {
|
|||
fn supports_limit_comma(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
fn supports_insert_table_function(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
fn supports_insert_format(&self) -> bool {
|
||||
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.
|
||||
//
|
||||
// [ClickHouse formats](https://clickhouse.com/docs/en/interfaces/formats)
|
||||
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
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -59,9 +59,4 @@ impl Dialect for DatabricksDialect {
|
|||
fn require_interval_qualifier(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
// See https://docs.databricks.com/en/sql/language-manual/functions/struct.html
|
||||
fn supports_struct_literal(&self) -> bool {
|
||||
true
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -47,10 +47,6 @@ impl Dialect for DuckDbDialect {
|
|||
true
|
||||
}
|
||||
|
||||
fn supports_named_fn_args_with_assignment_operator(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
// DuckDB uses this syntax for `STRUCT`s.
|
||||
//
|
||||
// https://duckdb.org/docs/sql/data_types/struct.html#creating-structs
|
||||
|
|
@ -65,33 +61,9 @@ 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 {
|
||||
true
|
||||
}
|
||||
|
||||
/// See DuckDB <https://duckdb.org/docs/sql/statements/load_and_install.html#load>
|
||||
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
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -48,14 +48,6 @@ 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
|
||||
}
|
||||
|
|
@ -112,14 +104,6 @@ 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
|
||||
}
|
||||
|
|
@ -127,56 +111,4 @@ impl Dialect for GenericDialect {
|
|||
fn supports_try_convert(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
fn supports_comment_on(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
fn supports_load_extension(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
fn supports_named_fn_args_with_assignment_operator(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
fn supports_struct_literal(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
fn supports_empty_projections(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
fn supports_nested_comments(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
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
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -51,24 +51,4 @@ impl Dialect for HiveDialect {
|
|||
fn require_interval_qualifier(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
/// See <https://cwiki.apache.org/confluence/pages/viewpage.action?pageId=27362061#Tutorial-BuiltInOperators>
|
||||
fn supports_bang_not_operator(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
/// See <https://cwiki.apache.org/confluence/pages/viewpage.action?pageId=27362036#LanguageManualDML-Loadingfilesintotables>
|
||||
fn supports_load_data(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
/// 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
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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, GranteesType, Statement};
|
||||
use crate::ast::{ColumnOption, Expr, Statement};
|
||||
pub use crate::keywords;
|
||||
use crate::keywords::Keyword;
|
||||
use crate::parser::{Parser, ParserError};
|
||||
|
|
@ -75,15 +75,6 @@ macro_rules! dialect_of {
|
|||
};
|
||||
}
|
||||
|
||||
// Similar to above, but for applying directly against an instance of dialect
|
||||
// instead of a struct member named dialect. This avoids lifetime issues when
|
||||
// mixing match guards and token references.
|
||||
macro_rules! dialect_is {
|
||||
($dialect:ident is $($dialect_type:ty)|+) => {
|
||||
($($dialect.is::<$dialect_type>())||+)
|
||||
}
|
||||
}
|
||||
|
||||
/// Encapsulates the differences between SQL implementations.
|
||||
///
|
||||
/// # SQL Dialects
|
||||
|
|
@ -137,41 +128,16 @@ pub trait Dialect: Debug + Any {
|
|||
ch == '"' || ch == '`'
|
||||
}
|
||||
|
||||
/// Determine if a character starts a potential nested quoted identifier.
|
||||
/// Example: RedShift supports the following quote styles to all mean the same thing:
|
||||
/// ```sql
|
||||
/// SELECT 1 AS foo;
|
||||
/// SELECT 1 AS "foo";
|
||||
/// SELECT 1 AS [foo];
|
||||
/// SELECT 1 AS ["foo"];
|
||||
/// ```
|
||||
fn is_nested_delimited_identifier_start(&self, _ch: char) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
/// Only applicable whenever [`Self::is_nested_delimited_identifier_start`] returns true
|
||||
/// If the next sequence of tokens potentially represent a nested identifier, then this method
|
||||
/// returns a tuple containing the outer quote style, and if present, the inner (nested) quote style.
|
||||
///
|
||||
/// Example (Redshift):
|
||||
/// ```text
|
||||
/// `["foo"]` => Some(`[`, Some(`"`))
|
||||
/// `[foo]` => Some(`[`, None)
|
||||
/// `[0]` => None
|
||||
/// `"foo"` => None
|
||||
/// ```
|
||||
fn peek_nested_delimited_identifier_quotes(
|
||||
&self,
|
||||
mut _chars: Peekable<Chars<'_>>,
|
||||
) -> Option<(char, Option<char>)> {
|
||||
None
|
||||
}
|
||||
|
||||
/// Return the character used to quote identifiers.
|
||||
fn identifier_quote_style(&self, _identifier: &str) -> Option<char> {
|
||||
None
|
||||
}
|
||||
|
||||
/// Determine if quoted characters are proper for identifier
|
||||
fn is_proper_identifier_inside_quotes(&self, mut _chars: Peekable<Chars<'_>>) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
/// Determine if a character is a valid start character for an unquoted identifier
|
||||
fn is_identifier_start(&self, ch: char) -> bool;
|
||||
|
||||
|
|
@ -201,33 +167,6 @@ 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:
|
||||
|
|
@ -272,55 +211,11 @@ 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
|
||||
|
|
@ -331,55 +226,22 @@ pub trait Dialect: Debug + Any {
|
|||
false
|
||||
}
|
||||
|
||||
/// Returns true if the dialect supports `BEGIN {DEFERRED | IMMEDIATE | EXCLUSIVE | TRY | CATCH} [TRANSACTION]` statements
|
||||
/// Returns true if the dialect supports `BEGIN {DEFERRED | IMMEDIATE | EXCLUSIVE} [TRANSACTION]` statements
|
||||
fn supports_start_transaction_modifier(&self) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
/// Returns true if the dialect supports `END {TRY | CATCH}` statements
|
||||
fn supports_end_transaction_modifier(&self) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
/// Returns true if the dialect supports named arguments of the form `FUN(a = '1', b = '2')`.
|
||||
/// Returns true if the dialect supports named arguments of the form FUN(a = '1', b = '2').
|
||||
fn supports_named_fn_args_with_eq_operator(&self) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
/// Returns true if the dialect supports named arguments of the form `FUN(a : '1', b : '2')`.
|
||||
fn supports_named_fn_args_with_colon_operator(&self) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
/// Returns true if the dialect supports named arguments of the form `FUN(a := '1', b := '2')`.
|
||||
fn supports_named_fn_args_with_assignment_operator(&self) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
/// Returns true if the dialect supports named arguments of the form `FUN(a => '1', b => '2')`.
|
||||
fn supports_named_fn_args_with_rarrow_operator(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
/// Returns true if dialect supports argument name as arbitrary expression.
|
||||
/// e.g. `FUN(LOWER('a'):'1', b:'2')`
|
||||
/// Such function arguments are represented in the AST by the `FunctionArg::ExprNamed` variant,
|
||||
/// otherwise use the `FunctionArg::Named` variant (compatible reason).
|
||||
fn supports_named_fn_args_with_expr_name(&self) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
/// Returns true if the dialect supports identifiers starting with a numeric
|
||||
/// prefix such as tables named `59901_user_login`
|
||||
fn supports_numeric_prefix(&self) -> bool {
|
||||
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.
|
||||
|
|
@ -427,16 +289,6 @@ 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.
|
||||
///
|
||||
|
|
@ -481,95 +333,6 @@ pub trait Dialect: Debug + Any {
|
|||
self.supports_trailing_commas()
|
||||
}
|
||||
|
||||
/// Returns true if the dialect supports trailing commas in the `FROM` clause of a `SELECT` statement.
|
||||
/// 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
|
||||
/// ```sql
|
||||
/// SELECT * FROM db_name..table_name
|
||||
/// ```
|
||||
fn supports_object_name_double_dot_notation(&self) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
/// Return true if the dialect supports the STRUCT literal
|
||||
///
|
||||
/// Example
|
||||
/// ```sql
|
||||
/// SELECT STRUCT(1 as one, 'foo' as foo, false)
|
||||
/// ```
|
||||
fn supports_struct_literal(&self) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
/// Return true if the dialect supports empty projections in SELECT statements
|
||||
///
|
||||
/// Example
|
||||
/// ```sql
|
||||
/// SELECT from table_name
|
||||
/// ```
|
||||
fn supports_empty_projections(&self) -> bool {
|
||||
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.
|
||||
|
|
@ -615,7 +378,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)),
|
||||
|
|
@ -647,27 +410,20 @@ 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)),
|
||||
Token::Word(w) if w.keyword == Keyword::IN => Ok(p!(Between)),
|
||||
Token::Word(w) if w.keyword == Keyword::BETWEEN => Ok(p!(Between)),
|
||||
Token::Word(w) if w.keyword == Keyword::OVERLAPS => Ok(p!(Between)),
|
||||
Token::Word(w) if w.keyword == Keyword::LIKE => Ok(p!(Like)),
|
||||
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::Period => Ok(p!(Period)),
|
||||
Token::Assignment
|
||||
| Token::Eq
|
||||
Token::Eq
|
||||
| Token::Lt
|
||||
| Token::LtEq
|
||||
| Token::Neq
|
||||
|
|
@ -683,34 +439,18 @@ pub trait Dialect: Debug + Any {
|
|||
| Token::ExclamationMarkDoubleTilde
|
||||
| Token::ExclamationMarkDoubleTildeAsterisk
|
||||
| Token::Spaceship => Ok(p!(Eq)),
|
||||
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::Pipe => 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::CaretAt => {
|
||||
Ok(p!(DoubleColon))
|
||||
}
|
||||
Token::DoubleColon
|
||||
| Token::ExclamationMark
|
||||
| Token::LBracket
|
||||
| Token::Overlap
|
||||
| Token::CaretAt => Ok(p!(DoubleColon)),
|
||||
Token::Arrow
|
||||
| Token::LongArrow
|
||||
| Token::HashArrow
|
||||
|
|
@ -722,6 +462,7 @@ pub trait Dialect: Debug + Any {
|
|||
| Token::AtAt
|
||||
| Token::Question
|
||||
| Token::QuestionAnd
|
||||
| Token::QuestionPipe
|
||||
| Token::CustomBinaryOperator(_) => Ok(p!(PgOther)),
|
||||
_ => Ok(self.prec_unknown()),
|
||||
}
|
||||
|
|
@ -755,7 +496,6 @@ 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,
|
||||
|
|
@ -800,12 +540,6 @@ pub trait Dialect: Debug + Any {
|
|||
false
|
||||
}
|
||||
|
||||
/// Returns true if this dialect allows dollar placeholders
|
||||
/// e.g. `SELECT $var` (SQLite)
|
||||
fn supports_dollar_placeholder(&self) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
/// Does the dialect support with clause in create index statement?
|
||||
/// e.g. `CREATE INDEX idx ON t WITH (key = value, key2)`
|
||||
fn supports_create_index_with_clause(&self) -> bool {
|
||||
|
|
@ -841,17 +575,6 @@ pub trait Dialect: Debug + Any {
|
|||
false
|
||||
}
|
||||
|
||||
/// Returns true if the dialect supports `a!` expressions
|
||||
fn supports_factorial_operator(&self) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
/// Returns true if the dialect supports nested comments
|
||||
/// e.g. `/* /* nested */ */`
|
||||
fn supports_nested_comments(&self) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
/// Returns true if this dialect supports treating the equals operator `=` within a `SelectItem`
|
||||
/// as an alias assignment operator, rather than a boolean expression.
|
||||
/// For example: the following statements are equivalent for such a dialect:
|
||||
|
|
@ -868,214 +591,21 @@ pub trait Dialect: Debug + Any {
|
|||
false
|
||||
}
|
||||
|
||||
/// Returns true if the dialect supports `!a` syntax for boolean `NOT` expressions.
|
||||
fn supports_bang_not_operator(&self) -> bool {
|
||||
/// Returns true if the dialect supports the `LISTEN` statement
|
||||
fn supports_listen(&self) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
/// Returns true if the dialect supports the `LISTEN`, `UNLISTEN` and `NOTIFY` statements
|
||||
fn supports_listen_notify(&self) -> bool {
|
||||
/// Returns true if the dialect supports the `NOTIFY` statement
|
||||
fn supports_notify(&self) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
/// Returns true if the dialect supports the `LOAD DATA` statement
|
||||
fn supports_load_data(&self) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
/// Returns true if the dialect supports the `LOAD extension` statement
|
||||
fn supports_load_extension(&self) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
/// Returns true if this dialect expects the `TOP` option
|
||||
/// Returns true if this dialect expects the the `TOP` option
|
||||
/// before the `ALL`/`DISTINCT` options in a `SELECT` statement.
|
||||
fn supports_top_before_distinct(&self) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
/// Returns true if the dialect supports boolean literals (`true` and `false`).
|
||||
/// For example, in MSSQL these are treated as identifiers rather than boolean literals.
|
||||
fn supports_boolean_literals(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
/// Returns true if this dialect supports the `LIKE 'pattern'` option in
|
||||
/// a `SHOW` statement before the `IN` option
|
||||
fn supports_show_like_before_in(&self) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
/// Returns true if this dialect supports the `COMMENT` statement
|
||||
fn supports_comment_on(&self) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
/// Returns true if the dialect supports the `CREATE TABLE SELECT` statement
|
||||
fn supports_create_table_select(&self) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
/// Returns true if the dialect supports PartiQL for querying semi-structured data
|
||||
/// <https://partiql.org/index.html>
|
||||
fn supports_partiql(&self) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
/// Returns true if the specified keyword is reserved and cannot be
|
||||
/// used as an identifier without special handling like quoting.
|
||||
fn is_reserved_for_identifier(&self, kw: Keyword) -> bool {
|
||||
keywords::RESERVED_FOR_IDENTIFIER.contains(&kw)
|
||||
}
|
||||
|
||||
/// 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:
|
||||
///
|
||||
/// Table sample before alias: `SELECT * FROM tbl AS t TABLESAMPLE (10)`
|
||||
/// Table sample after alias: `SELECT * FROM tbl TABLESAMPLE (10) AS t`
|
||||
///
|
||||
/// <https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#_7_6_table_reference>
|
||||
fn supports_table_sample_before_alias(&self) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
/// Returns true if this dialect supports the `INSERT INTO ... SET col1 = 1, ...` syntax.
|
||||
///
|
||||
/// MySQL: <https://dev.mysql.com/doc/refman/8.4/en/insert.html>
|
||||
fn supports_insert_set(&self) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
/// Does the dialect support table function in insertion?
|
||||
fn supports_insert_table_function(&self) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
/// Does the dialect support insert formats, e.g. `INSERT INTO ... FORMAT <format>`
|
||||
fn supports_insert_format(&self) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
/// Returns true if this dialect supports `SET` statements without an explicit
|
||||
/// assignment operator such as `=`. For example: `SET SHOWPLAN_XML ON`.
|
||||
fn supports_set_stmt_without_operator(&self) -> bool {
|
||||
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 || self.is_column_alias(kw, parser)
|
||||
}
|
||||
|
||||
/// Returns true if the specified keyword should be parsed as a table factor alias.
|
||||
/// When explicit is true, the keyword is preceded by an `AS` word. Parser is provided
|
||||
/// to enable looking ahead if needed.
|
||||
fn is_table_factor_alias(&self, explicit: bool, kw: &Keyword, _parser: &mut Parser) -> bool {
|
||||
explicit || !keywords::RESERVED_FOR_TABLE_ALIAS.contains(kw)
|
||||
}
|
||||
|
||||
/// Returns true if this dialect supports querying historical table data
|
||||
/// by specifying which version of the data to query.
|
||||
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
|
||||
|
|
@ -1083,7 +613,6 @@ pub trait Dialect: Debug + Any {
|
|||
/// higher number -> higher precedence
|
||||
#[derive(Debug, Clone, Copy)]
|
||||
pub enum Precedence {
|
||||
Period,
|
||||
DoubleColon,
|
||||
AtTz,
|
||||
MulDivModOp,
|
||||
|
|
@ -1228,17 +757,6 @@ mod tests {
|
|||
self.0.is_delimited_identifier_start(ch)
|
||||
}
|
||||
|
||||
fn is_nested_delimited_identifier_start(&self, ch: char) -> bool {
|
||||
self.0.is_nested_delimited_identifier_start(ch)
|
||||
}
|
||||
|
||||
fn peek_nested_delimited_identifier_quotes(
|
||||
&self,
|
||||
chars: std::iter::Peekable<std::str::Chars<'_>>,
|
||||
) -> Option<(char, Option<char>)> {
|
||||
self.0.peek_nested_delimited_identifier_quotes(chars)
|
||||
}
|
||||
|
||||
fn identifier_quote_style(&self, identifier: &str) -> Option<char> {
|
||||
self.0.identifier_quote_style(identifier)
|
||||
}
|
||||
|
|
@ -1247,6 +765,13 @@ mod tests {
|
|||
self.0.supports_string_literal_backslash_escape()
|
||||
}
|
||||
|
||||
fn is_proper_identifier_inside_quotes(
|
||||
&self,
|
||||
chars: std::iter::Peekable<std::str::Chars<'_>>,
|
||||
) -> bool {
|
||||
self.0.is_proper_identifier_inside_quotes(chars)
|
||||
}
|
||||
|
||||
fn supports_filter_during_aggregation(&self) -> bool {
|
||||
self.0.supports_filter_during_aggregation()
|
||||
}
|
||||
|
|
|
|||
|
|
@ -15,19 +15,7 @@
|
|||
// 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)]
|
||||
|
|
@ -52,20 +40,12 @@ 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
|
||||
}
|
||||
|
|
@ -77,222 +57,4 @@ impl Dialect for MsSqlDialect {
|
|||
fn supports_try_convert(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
/// In MSSQL, there is no boolean type, and `true` and `false` are valid column names
|
||||
fn supports_boolean_literals(&self) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
fn supports_named_fn_args_with_colon_operator(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
fn supports_named_fn_args_with_expr_name(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
fn supports_named_fn_args_with_rarrow_operator(&self) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
fn supports_start_transaction_modifier(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
fn supports_end_transaction_modifier(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
/// See: <https://learn.microsoft.com/en-us/sql/t-sql/statements/set-statements-transact-sql>
|
||||
fn supports_set_stmt_without_operator(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
/// See: <https://learn.microsoft.com/en-us/sql/relational-databases/tables/querying-data-in-a-system-versioned-temporal-table>
|
||||
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)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -25,15 +25,6 @@ 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 {}
|
||||
|
|
@ -67,10 +58,6 @@ impl Dialect for MySqlDialect {
|
|||
true
|
||||
}
|
||||
|
||||
fn ignores_wildcard_escapes(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
fn supports_numeric_prefix(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
|
@ -110,46 +97,6 @@ impl Dialect for MySqlDialect {
|
|||
fn supports_limit_comma(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
/// See: <https://dev.mysql.com/doc/refman/8.4/en/create-table-select.html>
|
||||
fn supports_create_table_select(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
/// See: <https://dev.mysql.com/doc/refman/8.4/en/insert.html>
|
||||
fn supports_insert_set(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
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`
|
||||
|
|
@ -161,7 +108,7 @@ fn parse_lock_tables(parser: &mut Parser) -> Result<Statement, ParserError> {
|
|||
|
||||
// tbl_name [[AS] alias] lock_type
|
||||
fn parse_lock_table(parser: &mut Parser) -> Result<LockTable, ParserError> {
|
||||
let table = parser.parse_identifier()?;
|
||||
let table = parser.parse_identifier(false)?;
|
||||
let alias =
|
||||
parser.parse_optional_alias(&[Keyword::READ, Keyword::WRITE, Keyword::LOW_PRIORITY])?;
|
||||
let lock_type = parse_lock_tables_type(parser)?;
|
||||
|
|
|
|||
|
|
@ -28,6 +28,7 @@
|
|||
// limitations under the License.
|
||||
use log::debug;
|
||||
|
||||
use crate::ast::{CommentObject, ObjectName, Statement, UserDefinedTypeRepresentation};
|
||||
use crate::dialect::{Dialect, Precedence};
|
||||
use crate::keywords::Keyword;
|
||||
use crate::parser::{Parser, ParserError};
|
||||
|
|
@ -37,7 +38,6 @@ 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,6 +135,17 @@ impl Dialect for PostgreSqlDialect {
|
|||
}
|
||||
}
|
||||
|
||||
fn parse_statement(&self, parser: &mut Parser) -> Option<Result<Statement, ParserError>> {
|
||||
if parser.parse_keyword(Keyword::COMMENT) {
|
||||
Some(parse_comment(parser))
|
||||
} else 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
|
||||
}
|
||||
|
|
@ -145,7 +156,6 @@ 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,
|
||||
|
|
@ -183,83 +193,82 @@ impl Dialect for PostgreSqlDialect {
|
|||
}
|
||||
|
||||
/// see <https://www.postgresql.org/docs/current/sql-listen.html>
|
||||
/// see <https://www.postgresql.org/docs/current/sql-unlisten.html>
|
||||
fn supports_listen(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
/// see <https://www.postgresql.org/docs/current/sql-notify.html>
|
||||
fn supports_listen_notify(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
/// see <https://www.postgresql.org/docs/13/functions-math.html>
|
||||
fn supports_factorial_operator(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
/// see <https://www.postgresql.org/docs/current/sql-comment.html>
|
||||
fn supports_comment_on(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
/// See <https://www.postgresql.org/docs/current/sql-load.html>
|
||||
fn supports_load_extension(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
/// See <https://www.postgresql.org/docs/current/functions-json.html>
|
||||
///
|
||||
/// Required to support the colon in:
|
||||
/// ```sql
|
||||
/// SELECT json_object('a': 'b')
|
||||
/// ```
|
||||
fn supports_named_fn_args_with_colon_operator(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
/// See <https://www.postgresql.org/docs/current/functions-json.html>
|
||||
///
|
||||
/// Required to support the label in:
|
||||
/// ```sql
|
||||
/// SELECT json_object('label': 'value')
|
||||
/// ```
|
||||
fn supports_named_fn_args_with_expr_name(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
/// Return true if the dialect supports empty projections in SELECT statements
|
||||
///
|
||||
/// Example
|
||||
/// ```sql
|
||||
/// SELECT from table_name
|
||||
/// ```
|
||||
fn supports_empty_projections(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
fn supports_nested_comments(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
fn supports_string_escape_constant(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
fn supports_numeric_literal_underscores(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
/// 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 {
|
||||
fn supports_notify(&self) -> bool {
|
||||
true
|
||||
}
|
||||
}
|
||||
|
||||
pub fn parse_comment(parser: &mut Parser) -> Result<Statement, ParserError> {
|
||||
let if_exists = parser.parse_keywords(&[Keyword::IF, Keyword::EXISTS]);
|
||||
|
||||
parser.expect_keyword(Keyword::ON)?;
|
||||
let token = parser.next_token();
|
||||
|
||||
let (object_type, object_name) = match token.token {
|
||||
Token::Word(w) if w.keyword == Keyword::COLUMN => {
|
||||
let object_name = parser.parse_object_name(false)?;
|
||||
(CommentObject::Column, object_name)
|
||||
}
|
||||
Token::Word(w) if w.keyword == Keyword::TABLE => {
|
||||
let object_name = parser.parse_object_name(false)?;
|
||||
(CommentObject::Table, object_name)
|
||||
}
|
||||
Token::Word(w) if w.keyword == Keyword::EXTENSION => {
|
||||
let object_name = parser.parse_object_name(false)?;
|
||||
(CommentObject::Extension, object_name)
|
||||
}
|
||||
_ => parser.expected("comment object_type", token)?,
|
||||
};
|
||||
|
||||
parser.expect_keyword(Keyword::IS)?;
|
||||
let comment = if parser.parse_keyword(Keyword::NULL) {
|
||||
None
|
||||
} else {
|
||||
Some(parser.parse_literal_string()?)
|
||||
};
|
||||
Ok(Statement::Comment {
|
||||
object_type,
|
||||
object_name,
|
||||
comment,
|
||||
if_exists,
|
||||
})
|
||||
}
|
||||
|
||||
pub fn parse_create(parser: &mut Parser) -> Option<Result<Statement, ParserError>> {
|
||||
let name = parser.maybe_parse(|parser| -> Result<ObjectName, ParserError> {
|
||||
parser.expect_keyword(Keyword::CREATE)?;
|
||||
parser.expect_keyword(Keyword::TYPE)?;
|
||||
let name = parser.parse_object_name(false)?;
|
||||
parser.expect_keyword(Keyword::AS)?;
|
||||
parser.expect_keyword(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());
|
||||
}
|
||||
|
||||
let labels = parser.parse_comma_separated0(|p| p.parse_identifier(false), Token::RParen)?;
|
||||
parser.expect_token(&Token::RParen)?;
|
||||
|
||||
Ok(Statement::CreateType {
|
||||
name,
|
||||
representation: UserDefinedTypeRepresentation::Enum { labels },
|
||||
})
|
||||
}
|
||||
|
|
|
|||
|
|
@ -32,63 +32,31 @@ pub struct RedshiftSqlDialect {}
|
|||
// in the Postgres dialect, the query will be parsed as an array, while in the Redshift dialect it will
|
||||
// be a json path
|
||||
impl Dialect for RedshiftSqlDialect {
|
||||
/// Determine if a character starts a potential nested quoted identifier.
|
||||
/// Example: RedShift supports the following quote styles to all mean the same thing:
|
||||
/// ```sql
|
||||
/// SELECT 1 AS foo;
|
||||
/// SELECT 1 AS "foo";
|
||||
/// SELECT 1 AS [foo];
|
||||
/// SELECT 1 AS ["foo"];
|
||||
/// ```
|
||||
fn is_nested_delimited_identifier_start(&self, ch: char) -> bool {
|
||||
ch == '['
|
||||
fn is_delimited_identifier_start(&self, ch: char) -> bool {
|
||||
ch == '"' || ch == '['
|
||||
}
|
||||
|
||||
/// Only applicable whenever [`Self::is_nested_delimited_identifier_start`] returns true
|
||||
/// If the next sequence of tokens potentially represent a nested identifier, then this method
|
||||
/// returns a tuple containing the outer quote style, and if present, the inner (nested) quote style.
|
||||
///
|
||||
/// Example (Redshift):
|
||||
/// ```text
|
||||
/// `["foo"]` => Some(`[`, Some(`"`))
|
||||
/// `[foo]` => Some(`[`, None)
|
||||
/// `[0]` => None
|
||||
/// `"foo"` => None
|
||||
/// ```
|
||||
fn peek_nested_delimited_identifier_quotes(
|
||||
&self,
|
||||
mut chars: Peekable<Chars<'_>>,
|
||||
) -> Option<(char, Option<char>)> {
|
||||
if chars.peek() != Some(&'[') {
|
||||
return None;
|
||||
}
|
||||
|
||||
/// Determine if quoted characters are proper for identifier
|
||||
/// It's needed to distinguish treating square brackets as quotes from
|
||||
/// treating them as json path. If there is identifier then we assume
|
||||
/// there is no json path.
|
||||
fn is_proper_identifier_inside_quotes(&self, mut chars: Peekable<Chars<'_>>) -> bool {
|
||||
chars.next();
|
||||
|
||||
let mut not_white_chars = chars.skip_while(|ch| ch.is_whitespace()).peekable();
|
||||
|
||||
if let Some(&ch) = not_white_chars.peek() {
|
||||
if ch == '"' {
|
||||
return Some(('[', Some('"')));
|
||||
}
|
||||
if self.is_identifier_start(ch) {
|
||||
return Some(('[', None));
|
||||
}
|
||||
return self.is_identifier_start(ch);
|
||||
}
|
||||
|
||||
None
|
||||
false
|
||||
}
|
||||
|
||||
fn is_identifier_start(&self, ch: char) -> bool {
|
||||
// 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()
|
||||
// Extends Postgres dialect with sharp
|
||||
PostgreSqlDialect {}.is_identifier_start(ch) || ch == '#'
|
||||
}
|
||||
|
||||
fn is_identifier_part(&self, ch: char) -> bool {
|
||||
// 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()
|
||||
// Extends Postgres dialect with sharp
|
||||
PostgreSqlDialect {}.is_identifier_part(ch) || ch == '#'
|
||||
}
|
||||
|
||||
/// redshift has `CONVERT(type, value)` instead of `CONVERT(value, type)`
|
||||
|
|
@ -106,29 +74,4 @@ impl Dialect for RedshiftSqlDialect {
|
|||
fn supports_top_before_distinct(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
/// Redshift supports PartiQL: <https://docs.aws.amazon.com/redshift/latest/dg/super-overview.html>
|
||||
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
|
||||
}
|
||||
}
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -15,11 +15,7 @@
|
|||
// specific language governing permissions and limitations
|
||||
// under the License.
|
||||
|
||||
#[cfg(not(feature = "std"))]
|
||||
use alloc::boxed::Box;
|
||||
|
||||
use crate::ast::BinaryOperator;
|
||||
use crate::ast::{Expr, Statement};
|
||||
use crate::ast::Statement;
|
||||
use crate::dialect::Dialect;
|
||||
use crate::keywords::Keyword;
|
||||
use crate::parser::{Parser, ParserError};
|
||||
|
|
@ -74,27 +70,6 @@ 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
|
||||
}
|
||||
|
|
@ -106,8 +81,4 @@ impl Dialect for SQLiteDialect {
|
|||
fn supports_asc_desc_in_column_definition(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
fn supports_dollar_placeholder(&self) -> bool {
|
||||
true
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,135 +0,0 @@
|
|||
// 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");
|
||||
}
|
||||
}
|
||||
227
src/keywords.rs
227
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};
|
||||
|
|
@ -74,19 +74,14 @@ macro_rules! define_keywords {
|
|||
define_keywords!(
|
||||
ABORT,
|
||||
ABS,
|
||||
ABSENT,
|
||||
ABSOLUTE,
|
||||
ACCESS,
|
||||
ACCOUNT,
|
||||
ACTION,
|
||||
ADD,
|
||||
ADMIN,
|
||||
AFTER,
|
||||
AGAINST,
|
||||
AGGREGATE,
|
||||
AGGREGATION,
|
||||
ALERT,
|
||||
ALGORITHM,
|
||||
ALIAS,
|
||||
ALL,
|
||||
ALLOCATE,
|
||||
|
|
@ -96,9 +91,7 @@ define_keywords!(
|
|||
AND,
|
||||
ANTI,
|
||||
ANY,
|
||||
APPLICATION,
|
||||
APPLY,
|
||||
APPLYBUDGET,
|
||||
ARCHIVE,
|
||||
ARE,
|
||||
ARRAY,
|
||||
|
|
@ -112,44 +105,31 @@ 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,
|
||||
BEGIN_PARTITION,
|
||||
BERNOULLI,
|
||||
BETWEEN,
|
||||
BIGDECIMAL,
|
||||
BIGINT,
|
||||
BIGNUMERIC,
|
||||
BINARY,
|
||||
BIND,
|
||||
BINDING,
|
||||
BIT,
|
||||
BLOB,
|
||||
BLOCK,
|
||||
BLOOM,
|
||||
BLOOMFILTER,
|
||||
BOOL,
|
||||
BOOLEAN,
|
||||
BOTH,
|
||||
BOX,
|
||||
BRIN,
|
||||
BROWSE,
|
||||
BTREE,
|
||||
BUCKET,
|
||||
BUCKETS,
|
||||
BY,
|
||||
BYPASSRLS,
|
||||
|
|
@ -162,11 +142,8 @@ define_keywords!(
|
|||
CASCADE,
|
||||
CASCADED,
|
||||
CASE,
|
||||
CASES,
|
||||
CAST,
|
||||
CATALOG,
|
||||
CATALOG_SYNC,
|
||||
CATCH,
|
||||
CEIL,
|
||||
CEILING,
|
||||
CENTURY,
|
||||
|
|
@ -176,21 +153,17 @@ define_keywords!(
|
|||
CHANNEL,
|
||||
CHAR,
|
||||
CHARACTER,
|
||||
CHARACTERISTICS,
|
||||
CHARACTERS,
|
||||
CHARACTER_LENGTH,
|
||||
CHARSET,
|
||||
CHAR_LENGTH,
|
||||
CHECK,
|
||||
CHECKSUM,
|
||||
CIRCLE,
|
||||
CLEAR,
|
||||
CLOB,
|
||||
CLONE,
|
||||
CLOSE,
|
||||
CLUSTER,
|
||||
CLUSTERED,
|
||||
CLUSTERING,
|
||||
COALESCE,
|
||||
COLLATE,
|
||||
COLLATION,
|
||||
|
|
@ -202,7 +175,6 @@ define_keywords!(
|
|||
COMMENT,
|
||||
COMMIT,
|
||||
COMMITTED,
|
||||
COMPATIBLE,
|
||||
COMPRESSION,
|
||||
COMPUTE,
|
||||
CONCURRENTLY,
|
||||
|
|
@ -210,8 +182,6 @@ define_keywords!(
|
|||
CONFLICT,
|
||||
CONNECT,
|
||||
CONNECTION,
|
||||
CONNECTOR,
|
||||
CONNECT_BY_ROOT,
|
||||
CONSTRAINT,
|
||||
CONTAINS,
|
||||
CONTINUE,
|
||||
|
|
@ -256,8 +226,6 @@ define_keywords!(
|
|||
DAY,
|
||||
DAYOFWEEK,
|
||||
DAYOFYEAR,
|
||||
DAYS,
|
||||
DCPROPERTIES,
|
||||
DEALLOCATE,
|
||||
DEC,
|
||||
DECADE,
|
||||
|
|
@ -270,15 +238,12 @@ define_keywords!(
|
|||
DEFERRED,
|
||||
DEFINE,
|
||||
DEFINED,
|
||||
DEFINER,
|
||||
DELAYED,
|
||||
DELAY_KEY_WRITE,
|
||||
DELETE,
|
||||
DELIMITED,
|
||||
DELIMITER,
|
||||
DELTA,
|
||||
DENSE_RANK,
|
||||
DENY,
|
||||
DEREF,
|
||||
DESC,
|
||||
DESCRIBE,
|
||||
|
|
@ -293,7 +258,6 @@ define_keywords!(
|
|||
DISTRIBUTE,
|
||||
DIV,
|
||||
DO,
|
||||
DOMAIN,
|
||||
DOUBLE,
|
||||
DOW,
|
||||
DOY,
|
||||
|
|
@ -305,7 +269,6 @@ define_keywords!(
|
|||
ELEMENT,
|
||||
ELEMENTS,
|
||||
ELSE,
|
||||
ELSEIF,
|
||||
EMPTY,
|
||||
ENABLE,
|
||||
ENABLE_SCHEMA_EVOLUTION,
|
||||
|
|
@ -318,42 +281,32 @@ define_keywords!(
|
|||
END_PARTITION,
|
||||
ENFORCED,
|
||||
ENGINE,
|
||||
ENGINE_ATTRIBUTE,
|
||||
ENUM,
|
||||
ENUM16,
|
||||
ENUM8,
|
||||
EPHEMERAL,
|
||||
EPOCH,
|
||||
EQUALS,
|
||||
ERROR,
|
||||
ESCAPE,
|
||||
ESCAPED,
|
||||
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,
|
||||
|
|
@ -373,7 +326,6 @@ define_keywords!(
|
|||
FLOAT8,
|
||||
FLOOR,
|
||||
FLUSH,
|
||||
FN,
|
||||
FOLLOWING,
|
||||
FOR,
|
||||
FORCE,
|
||||
|
|
@ -389,20 +341,16 @@ define_keywords!(
|
|||
FREEZE,
|
||||
FROM,
|
||||
FSCK,
|
||||
FULFILLMENT,
|
||||
FULL,
|
||||
FULLTEXT,
|
||||
FUNCTION,
|
||||
FUNCTIONS,
|
||||
FUSION,
|
||||
FUTURE,
|
||||
GENERAL,
|
||||
GENERATE,
|
||||
GENERATED,
|
||||
GEOGRAPHY,
|
||||
GET,
|
||||
GIN,
|
||||
GIST,
|
||||
GLOBAL,
|
||||
GRANT,
|
||||
GRANTED,
|
||||
|
|
@ -422,18 +370,13 @@ define_keywords!(
|
|||
HOSTS,
|
||||
HOUR,
|
||||
HOURS,
|
||||
HUGEINT,
|
||||
ICEBERG,
|
||||
ID,
|
||||
IDENTITY,
|
||||
IDENTITY_INSERT,
|
||||
IF,
|
||||
IGNORE,
|
||||
ILIKE,
|
||||
IMMEDIATE,
|
||||
IMMUTABLE,
|
||||
IMPORT,
|
||||
IMPORTED,
|
||||
IN,
|
||||
INCLUDE,
|
||||
INCLUDE_NULL_VALUES,
|
||||
|
|
@ -441,19 +384,14 @@ define_keywords!(
|
|||
INDEX,
|
||||
INDICATOR,
|
||||
INHERIT,
|
||||
INHERITS,
|
||||
INITIALLY,
|
||||
INNER,
|
||||
INOUT,
|
||||
INPATH,
|
||||
INPLACE,
|
||||
INPUT,
|
||||
INPUTFORMAT,
|
||||
INSENSITIVE,
|
||||
INSERT,
|
||||
INSERT_METHOD,
|
||||
INSTALL,
|
||||
INSTANT,
|
||||
INSTEAD,
|
||||
INT,
|
||||
INT128,
|
||||
|
|
@ -465,14 +403,11 @@ define_keywords!(
|
|||
INT64,
|
||||
INT8,
|
||||
INTEGER,
|
||||
INTEGRATION,
|
||||
INTERPOLATE,
|
||||
INTERSECT,
|
||||
INTERSECTION,
|
||||
INTERVAL,
|
||||
INTO,
|
||||
INVOKER,
|
||||
IO,
|
||||
IS,
|
||||
ISODOW,
|
||||
ISOLATION,
|
||||
|
|
@ -488,7 +423,6 @@ define_keywords!(
|
|||
JULIAN,
|
||||
KEY,
|
||||
KEYS,
|
||||
KEY_BLOCK_SIZE,
|
||||
KILL,
|
||||
LAG,
|
||||
LANGUAGE,
|
||||
|
|
@ -503,11 +437,8 @@ define_keywords!(
|
|||
LIKE,
|
||||
LIKE_REGEX,
|
||||
LIMIT,
|
||||
LINE,
|
||||
LINES,
|
||||
LIST,
|
||||
LISTEN,
|
||||
LISTING,
|
||||
LN,
|
||||
LOAD,
|
||||
LOCAL,
|
||||
|
|
@ -516,19 +447,12 @@ define_keywords!(
|
|||
LOCATION,
|
||||
LOCK,
|
||||
LOCKED,
|
||||
LOG,
|
||||
LOGIN,
|
||||
LOGS,
|
||||
LONGBLOB,
|
||||
LONGTEXT,
|
||||
LOWCARDINALITY,
|
||||
LOWER,
|
||||
LOW_PRIORITY,
|
||||
LS,
|
||||
LSEG,
|
||||
MACRO,
|
||||
MANAGE,
|
||||
MANAGED,
|
||||
MANAGEDLOCATION,
|
||||
MAP,
|
||||
MASKING,
|
||||
|
|
@ -542,17 +466,12 @@ 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,
|
||||
|
|
@ -560,24 +479,18 @@ define_keywords!(
|
|||
MILLISECOND,
|
||||
MILLISECONDS,
|
||||
MIN,
|
||||
MINUS,
|
||||
MINUTE,
|
||||
MINUTES,
|
||||
MINVALUE,
|
||||
MIN_ROWS,
|
||||
MOD,
|
||||
MODE,
|
||||
MODIFIES,
|
||||
MODIFY,
|
||||
MODULE,
|
||||
MONITOR,
|
||||
MONTH,
|
||||
MONTHS,
|
||||
MSCK,
|
||||
MULTISET,
|
||||
MUTATION,
|
||||
NAME,
|
||||
NAMES,
|
||||
NANOSECOND,
|
||||
NANOSECONDS,
|
||||
NATIONAL,
|
||||
|
|
@ -585,13 +498,8 @@ define_keywords!(
|
|||
NCHAR,
|
||||
NCLOB,
|
||||
NESTED,
|
||||
NETWORK,
|
||||
NEW,
|
||||
NEXT,
|
||||
NFC,
|
||||
NFD,
|
||||
NFKC,
|
||||
NFKD,
|
||||
NO,
|
||||
NOBYPASSRLS,
|
||||
NOCREATEDB,
|
||||
|
|
@ -602,7 +510,6 @@ define_keywords!(
|
|||
NOORDER,
|
||||
NOREPLICATION,
|
||||
NORMALIZE,
|
||||
NORMALIZED,
|
||||
NOSCAN,
|
||||
NOSUPERUSER,
|
||||
NOT,
|
||||
|
|
@ -619,26 +526,19 @@ define_keywords!(
|
|||
NUMERIC,
|
||||
NVARCHAR,
|
||||
OBJECT,
|
||||
OBJECTS,
|
||||
OCCURRENCES_REGEX,
|
||||
OCTETS,
|
||||
OCTET_LENGTH,
|
||||
OF,
|
||||
OFF,
|
||||
OFFSET,
|
||||
OFFSETS,
|
||||
OLD,
|
||||
OMIT,
|
||||
ON,
|
||||
ONE,
|
||||
ONLY,
|
||||
OPEN,
|
||||
OPENJSON,
|
||||
OPERATE,
|
||||
OPERATOR,
|
||||
OPTIMIZATION,
|
||||
OPTIMIZE,
|
||||
OPTIMIZED,
|
||||
OPTIMIZER_COSTS,
|
||||
OPTION,
|
||||
OPTIONS,
|
||||
|
|
@ -646,24 +546,16 @@ 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,
|
||||
|
|
@ -671,7 +563,6 @@ define_keywords!(
|
|||
PARTITION,
|
||||
PARTITIONED,
|
||||
PARTITIONS,
|
||||
PASSING,
|
||||
PASSWORD,
|
||||
PAST,
|
||||
PATH,
|
||||
|
|
@ -688,10 +579,7 @@ define_keywords!(
|
|||
PLACING,
|
||||
PLAN,
|
||||
PLANS,
|
||||
POINT,
|
||||
POLICY,
|
||||
POLYGON,
|
||||
POOL,
|
||||
PORTION,
|
||||
POSITION,
|
||||
POSITION_REGEX,
|
||||
|
|
@ -704,22 +592,16 @@ define_keywords!(
|
|||
PRESERVE,
|
||||
PREWHERE,
|
||||
PRIMARY,
|
||||
PRINT,
|
||||
PRIOR,
|
||||
PRIVILEGES,
|
||||
PROCEDURE,
|
||||
PROFILE,
|
||||
PROGRAM,
|
||||
PROJECTION,
|
||||
PUBLIC,
|
||||
PURCHASE,
|
||||
PURGE,
|
||||
QUALIFY,
|
||||
QUARTER,
|
||||
QUERY,
|
||||
QUOTE,
|
||||
RAISE,
|
||||
RAISERROR,
|
||||
RANGE,
|
||||
RANK,
|
||||
RAW,
|
||||
|
|
@ -728,7 +610,6 @@ define_keywords!(
|
|||
READS,
|
||||
READ_ONLY,
|
||||
REAL,
|
||||
RECLUSTER,
|
||||
RECURSIVE,
|
||||
REF,
|
||||
REFERENCES,
|
||||
|
|
@ -747,29 +628,22 @@ define_keywords!(
|
|||
RELATIVE,
|
||||
RELAY,
|
||||
RELEASE,
|
||||
RELEASES,
|
||||
REMOTE,
|
||||
REMOVE,
|
||||
RENAME,
|
||||
REORG,
|
||||
REPAIR,
|
||||
REPEATABLE,
|
||||
REPLACE,
|
||||
REPLICA,
|
||||
REPLICATE,
|
||||
REPLICATION,
|
||||
RESET,
|
||||
RESOLVE,
|
||||
RESOURCE,
|
||||
RESPECT,
|
||||
RESTART,
|
||||
RESTRICT,
|
||||
RESTRICTED,
|
||||
RESTRICTIONS,
|
||||
RESTRICTIVE,
|
||||
RESULT,
|
||||
RESULTSET,
|
||||
RESUME,
|
||||
RETAIN,
|
||||
RETURN,
|
||||
RETURNING,
|
||||
|
|
@ -777,22 +651,18 @@ define_keywords!(
|
|||
REVOKE,
|
||||
RIGHT,
|
||||
RLIKE,
|
||||
RM,
|
||||
ROLE,
|
||||
ROLES,
|
||||
ROLLBACK,
|
||||
ROLLUP,
|
||||
ROOT,
|
||||
ROW,
|
||||
ROWID,
|
||||
ROWS,
|
||||
ROW_FORMAT,
|
||||
ROW_NUMBER,
|
||||
RULE,
|
||||
RUN,
|
||||
SAFE,
|
||||
SAFE_CAST,
|
||||
SAMPLE,
|
||||
SAVEPOINT,
|
||||
SCHEMA,
|
||||
SCHEMAS,
|
||||
|
|
@ -800,12 +670,8 @@ define_keywords!(
|
|||
SCROLL,
|
||||
SEARCH,
|
||||
SECOND,
|
||||
SECONDARY,
|
||||
SECONDARY_ENGINE_ATTRIBUTE,
|
||||
SECONDS,
|
||||
SECRET,
|
||||
SECURITY,
|
||||
SEED,
|
||||
SELECT,
|
||||
SEMI,
|
||||
SENSITIVE,
|
||||
|
|
@ -816,19 +682,13 @@ define_keywords!(
|
|||
SERDE,
|
||||
SERDEPROPERTIES,
|
||||
SERIALIZABLE,
|
||||
SERVER,
|
||||
SERVICE,
|
||||
SESSION,
|
||||
SESSION_USER,
|
||||
SET,
|
||||
SETERROR,
|
||||
SETS,
|
||||
SETTINGS,
|
||||
SHARE,
|
||||
SHARED,
|
||||
SHARING,
|
||||
SHOW,
|
||||
SIGNED,
|
||||
SIMILAR,
|
||||
SKIP,
|
||||
SLOW,
|
||||
|
|
@ -841,47 +701,35 @@ define_keywords!(
|
|||
SPATIAL,
|
||||
SPECIFIC,
|
||||
SPECIFICTYPE,
|
||||
SPGIST,
|
||||
SQL,
|
||||
SQLEXCEPTION,
|
||||
SQLSTATE,
|
||||
SQLWARNING,
|
||||
SQRT,
|
||||
SRID,
|
||||
STABLE,
|
||||
STAGE,
|
||||
START,
|
||||
STARTS,
|
||||
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,
|
||||
SYNC,
|
||||
|
|
@ -891,16 +739,12 @@ define_keywords!(
|
|||
TABLE,
|
||||
TABLES,
|
||||
TABLESAMPLE,
|
||||
TABLESPACE,
|
||||
TAG,
|
||||
TARGET,
|
||||
TASK,
|
||||
TBLPROPERTIES,
|
||||
TEMP,
|
||||
TEMPORARY,
|
||||
TEMPTABLE,
|
||||
TERMINATED,
|
||||
TERSE,
|
||||
TEXT,
|
||||
TEXTFILE,
|
||||
THEN,
|
||||
|
|
@ -908,20 +752,16 @@ define_keywords!(
|
|||
TIME,
|
||||
TIMESTAMP,
|
||||
TIMESTAMPTZ,
|
||||
TIMESTAMP_NTZ,
|
||||
TIMETZ,
|
||||
TIMEZONE,
|
||||
TIMEZONE_ABBR,
|
||||
TIMEZONE_HOUR,
|
||||
TIMEZONE_MINUTE,
|
||||
TIMEZONE_REGION,
|
||||
TINYBLOB,
|
||||
TINYINT,
|
||||
TINYTEXT,
|
||||
TO,
|
||||
TOP,
|
||||
TOTALS,
|
||||
TRACE,
|
||||
TRAILING,
|
||||
TRANSACTION,
|
||||
TRANSIENT,
|
||||
|
|
@ -934,16 +774,11 @@ define_keywords!(
|
|||
TRIM_ARRAY,
|
||||
TRUE,
|
||||
TRUNCATE,
|
||||
TRY,
|
||||
TRY_CAST,
|
||||
TRY_CONVERT,
|
||||
TSQUERY,
|
||||
TSVECTOR,
|
||||
TUPLE,
|
||||
TYPE,
|
||||
UBIGINT,
|
||||
UESCAPE,
|
||||
UHUGEINT,
|
||||
UINT128,
|
||||
UINT16,
|
||||
UINT256,
|
||||
|
|
@ -953,12 +788,10 @@ define_keywords!(
|
|||
UNBOUNDED,
|
||||
UNCACHE,
|
||||
UNCOMMITTED,
|
||||
UNDEFINED,
|
||||
UNFREEZE,
|
||||
UNION,
|
||||
UNIQUE,
|
||||
UNKNOWN,
|
||||
UNLISTEN,
|
||||
UNLOAD,
|
||||
UNLOCK,
|
||||
UNLOGGED,
|
||||
|
|
@ -966,7 +799,6 @@ define_keywords!(
|
|||
UNNEST,
|
||||
UNPIVOT,
|
||||
UNSAFE,
|
||||
UNSET,
|
||||
UNSIGNED,
|
||||
UNTIL,
|
||||
UPDATE,
|
||||
|
|
@ -977,18 +809,14 @@ define_keywords!(
|
|||
USER,
|
||||
USER_RESOURCES,
|
||||
USING,
|
||||
USMALLINT,
|
||||
UTINYINT,
|
||||
UUID,
|
||||
VACUUM,
|
||||
VALID,
|
||||
VALIDATE,
|
||||
VALIDATION_MODE,
|
||||
VALUE,
|
||||
VALUES,
|
||||
VALUE_OF,
|
||||
VARBINARY,
|
||||
VARBIT,
|
||||
VARCHAR,
|
||||
VARIABLES,
|
||||
VARYING,
|
||||
|
|
@ -997,20 +825,15 @@ define_keywords!(
|
|||
VERBOSE,
|
||||
VERSION,
|
||||
VERSIONING,
|
||||
VERSIONS,
|
||||
VIEW,
|
||||
VIEWS,
|
||||
VIRTUAL,
|
||||
VOLATILE,
|
||||
VOLUME,
|
||||
WAREHOUSE,
|
||||
WAREHOUSES,
|
||||
WEEK,
|
||||
WEEKS,
|
||||
WHEN,
|
||||
WHENEVER,
|
||||
WHERE,
|
||||
WHILE,
|
||||
WIDTH_BUCKET,
|
||||
WINDOW,
|
||||
WITH,
|
||||
|
|
@ -1018,14 +841,10 @@ define_keywords!(
|
|||
WITHOUT,
|
||||
WITHOUT_ARRAY_WRAPPER,
|
||||
WORK,
|
||||
WRAPPER,
|
||||
WRITE,
|
||||
XML,
|
||||
XMLNAMESPACES,
|
||||
XMLTABLE,
|
||||
XOR,
|
||||
YEAR,
|
||||
YEARS,
|
||||
ZONE,
|
||||
ZORDER
|
||||
);
|
||||
|
|
@ -1054,7 +873,6 @@ pub const RESERVED_FOR_TABLE_ALIAS: &[Keyword] = &[
|
|||
Keyword::UNION,
|
||||
Keyword::EXCEPT,
|
||||
Keyword::INTERSECT,
|
||||
Keyword::MINUS,
|
||||
// Reserved only as a table alias in the `FROM`/`JOIN` clauses:
|
||||
Keyword::ON,
|
||||
Keyword::JOIN,
|
||||
|
|
@ -1068,11 +886,6 @@ pub const RESERVED_FOR_TABLE_ALIAS: &[Keyword] = &[
|
|||
Keyword::CLUSTER,
|
||||
Keyword::DISTRIBUTE,
|
||||
Keyword::GLOBAL,
|
||||
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,
|
||||
|
|
@ -1084,18 +897,15 @@ pub const RESERVED_FOR_TABLE_ALIAS: &[Keyword] = &[
|
|||
Keyword::PARTITION,
|
||||
// for Clickhouse PREWHERE
|
||||
Keyword::PREWHERE,
|
||||
// for ClickHouse SELECT * FROM t SETTINGS ...
|
||||
Keyword::SETTINGS,
|
||||
// for ClickHouse SELECT * FROM t FORMAT...
|
||||
Keyword::FORMAT,
|
||||
// for Snowflake START WITH .. CONNECT BY
|
||||
Keyword::START,
|
||||
Keyword::CONNECT,
|
||||
// Reserved for snowflake MATCH_RECOGNIZE
|
||||
Keyword::MATCH_RECOGNIZE,
|
||||
// Reserved for Snowflake table sample
|
||||
Keyword::SAMPLE,
|
||||
Keyword::TABLESAMPLE,
|
||||
Keyword::FROM,
|
||||
Keyword::OPEN,
|
||||
];
|
||||
|
||||
/// Can't be used as a column alias, so that `SELECT <expr> alias`
|
||||
|
|
@ -1120,7 +930,6 @@ pub const RESERVED_FOR_COLUMN_ALIAS: &[Keyword] = &[
|
|||
Keyword::UNION,
|
||||
Keyword::EXCEPT,
|
||||
Keyword::INTERSECT,
|
||||
Keyword::MINUS,
|
||||
Keyword::CLUSTER,
|
||||
Keyword::DISTRIBUTE,
|
||||
Keyword::RETURNING,
|
||||
|
|
@ -1129,23 +938,3 @@ pub const RESERVED_FOR_COLUMN_ALIAS: &[Keyword] = &[
|
|||
Keyword::INTO,
|
||||
Keyword::END,
|
||||
];
|
||||
|
||||
// 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] = &[
|
||||
Keyword::INTO,
|
||||
Keyword::LIMIT,
|
||||
Keyword::HAVING,
|
||||
Keyword::WHERE,
|
||||
];
|
||||
|
||||
/// Global list of reserved keywords that cannot be parsed as identifiers
|
||||
/// without special handling like quoting. Parser should call `Dialect::is_reserved_for_identifier`
|
||||
/// to allow for each dialect to customize the list.
|
||||
pub const RESERVED_FOR_IDENTIFIER: &[Keyword] = &[
|
||||
Keyword::EXISTS,
|
||||
Keyword::INTERVAL,
|
||||
Keyword::STRUCT,
|
||||
Keyword::TRIM,
|
||||
];
|
||||
|
|
|
|||
83
src/lib.rs
83
src/lib.rs
|
|
@ -25,9 +25,6 @@
|
|||
//! 1. [`Parser::parse_sql`] and [`Parser::new`] for the Parsing API
|
||||
//! 2. [`ast`] for the AST structure
|
||||
//! 3. [`Dialect`] for supported SQL dialects
|
||||
//! 4. [`Spanned`] for source text locations (see "Source Spans" below for details)
|
||||
//!
|
||||
//! [`Spanned`]: ast::Spanned
|
||||
//!
|
||||
//! # Example parsing SQL text
|
||||
//!
|
||||
|
|
@ -65,94 +62,15 @@
|
|||
//! 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
|
||||
//! [`AST`]: crate::ast
|
||||
//! [`ast`]: crate::ast
|
||||
//! [`Dialect`]: crate::dialect::Dialect
|
||||
//!
|
||||
//! # Source Spans
|
||||
//!
|
||||
//! Starting with version `0.53.0` sqlparser introduced source spans to the
|
||||
//! AST. This feature provides source information for syntax errors, enabling
|
||||
//! better error messages. See [issue #1548] for more information and the
|
||||
//! [`Spanned`] trait to access the spans.
|
||||
//!
|
||||
//! [issue #1548]: https://github.com/apache/datafusion-sqlparser-rs/issues/1548
|
||||
//! [`Spanned`]: ast::Spanned
|
||||
//!
|
||||
//! ## Migration Guide
|
||||
//!
|
||||
//! For the next few releases, we will be incrementally adding source spans to the
|
||||
//! AST nodes, trying to minimize the impact on existing users. Some breaking
|
||||
//! changes are inevitable, and the following is a summary of the changes:
|
||||
//!
|
||||
//! #### New fields for spans (must be added to any existing pattern matches)
|
||||
//!
|
||||
//! The primary change is that new fields will be added to AST nodes to store the source `Span` or `TokenWithLocation`.
|
||||
//!
|
||||
//! This will require
|
||||
//! 1. Adding new fields to existing pattern matches.
|
||||
//! 2. Filling in the proper span information when constructing AST nodes.
|
||||
//!
|
||||
//! For example, since `Ident` now stores a `Span`, to construct an `Ident` you
|
||||
//! must provide now provide one:
|
||||
//!
|
||||
//! Previously:
|
||||
//! ```text
|
||||
//! # use sqlparser::ast::Ident;
|
||||
//! Ident {
|
||||
//! value: "name".into(),
|
||||
//! quote_style: None,
|
||||
//! }
|
||||
//! ```
|
||||
//! Now
|
||||
//! ```rust
|
||||
//! # use sqlparser::ast::Ident;
|
||||
//! # use sqlparser::tokenizer::Span;
|
||||
//! Ident {
|
||||
//! value: "name".into(),
|
||||
//! quote_style: None,
|
||||
//! span: Span::empty(),
|
||||
//! };
|
||||
//! ```
|
||||
//!
|
||||
//! Similarly, when pattern matching on `Ident`, you must now account for the
|
||||
//! `span` field.
|
||||
//!
|
||||
//! #### Misc.
|
||||
//! - [`TokenWithLocation`] stores a full `Span`, rather than just a source location.
|
||||
//! Users relying on `token.location` should use `token.location.start` instead.
|
||||
//!
|
||||
//![`TokenWithLocation`]: tokenizer::TokenWithLocation
|
||||
|
||||
#![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;
|
||||
|
|
@ -167,7 +85,6 @@ extern crate pretty_assertions;
|
|||
pub mod ast;
|
||||
#[macro_use]
|
||||
pub mod dialect;
|
||||
mod display_utils;
|
||||
pub mod keywords;
|
||||
pub mod parser;
|
||||
pub mod tokenizer;
|
||||
|
|
|
|||
|
|
@ -18,15 +18,15 @@ use alloc::vec;
|
|||
use super::{Parser, ParserError};
|
||||
use crate::{
|
||||
ast::{
|
||||
AlterConnectorOwner, AlterPolicyOperation, AlterRoleOperation, Expr, Password, ResetConfig,
|
||||
RoleOption, SetConfigValue, Statement,
|
||||
AlterPolicyOperation, AlterRoleOperation, Expr, Password, ResetConfig, RoleOption,
|
||||
SetConfigValue, Statement,
|
||||
},
|
||||
dialect::{MsSqlDialect, PostgreSqlDialect},
|
||||
keywords::Keyword,
|
||||
tokenizer::Token,
|
||||
};
|
||||
|
||||
impl Parser<'_> {
|
||||
impl<'a> Parser<'a> {
|
||||
pub fn parse_alter_role(&mut self) -> Result<Statement, ParserError> {
|
||||
if dialect_of!(self is PostgreSqlDialect) {
|
||||
return self.parse_pg_alter_role();
|
||||
|
|
@ -51,13 +51,13 @@ impl Parser<'_> {
|
|||
///
|
||||
/// [PostgreSQL](https://www.postgresql.org/docs/current/sql-alterpolicy.html)
|
||||
pub fn parse_alter_policy(&mut self) -> Result<Statement, ParserError> {
|
||||
let name = self.parse_identifier()?;
|
||||
self.expect_keyword_is(Keyword::ON)?;
|
||||
let name = self.parse_identifier(false)?;
|
||||
self.expect_keyword(Keyword::ON)?;
|
||||
let table_name = self.parse_object_name(false)?;
|
||||
|
||||
if self.parse_keyword(Keyword::RENAME) {
|
||||
self.expect_keyword_is(Keyword::TO)?;
|
||||
let new_name = self.parse_identifier()?;
|
||||
self.expect_keyword(Keyword::TO)?;
|
||||
let new_name = self.parse_identifier(false)?;
|
||||
Ok(Statement::AlterPolicy {
|
||||
name,
|
||||
table_name,
|
||||
|
|
@ -99,59 +99,18 @@ 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()?;
|
||||
let role_name = self.parse_identifier(false)?;
|
||||
|
||||
let operation = if self.parse_keywords(&[Keyword::ADD, Keyword::MEMBER]) {
|
||||
let member_name = self.parse_identifier()?;
|
||||
let member_name = self.parse_identifier(false)?;
|
||||
AlterRoleOperation::AddMember { member_name }
|
||||
} else if self.parse_keywords(&[Keyword::DROP, Keyword::MEMBER]) {
|
||||
let member_name = self.parse_identifier()?;
|
||||
let member_name = self.parse_identifier(false)?;
|
||||
AlterRoleOperation::DropMember { member_name }
|
||||
} else if self.parse_keywords(&[Keyword::WITH, Keyword::NAME]) {
|
||||
if self.consume_token(&Token::Eq) {
|
||||
let role_name = self.parse_identifier()?;
|
||||
let role_name = self.parse_identifier(false)?;
|
||||
AlterRoleOperation::RenameRole { role_name }
|
||||
} else {
|
||||
return self.expected("= after WITH NAME ", self.peek_token());
|
||||
|
|
@ -167,7 +126,7 @@ impl Parser<'_> {
|
|||
}
|
||||
|
||||
fn parse_pg_alter_role(&mut self) -> Result<Statement, ParserError> {
|
||||
let role_name = self.parse_identifier()?;
|
||||
let role_name = self.parse_identifier(false)?;
|
||||
|
||||
// [ IN DATABASE _`database_name`_ ]
|
||||
let in_database = if self.parse_keywords(&[Keyword::IN, Keyword::DATABASE]) {
|
||||
|
|
@ -178,7 +137,7 @@ impl Parser<'_> {
|
|||
|
||||
let operation = if self.parse_keyword(Keyword::RENAME) {
|
||||
if self.parse_keyword(Keyword::TO) {
|
||||
let role_name = self.parse_identifier()?;
|
||||
let role_name = self.parse_identifier(false)?;
|
||||
AlterRoleOperation::RenameRole { role_name }
|
||||
} else {
|
||||
return self.expected("TO after RENAME", self.peek_token());
|
||||
|
|
@ -273,7 +232,7 @@ impl Parser<'_> {
|
|||
Some(Keyword::BYPASSRLS) => RoleOption::BypassRLS(true),
|
||||
Some(Keyword::NOBYPASSRLS) => RoleOption::BypassRLS(false),
|
||||
Some(Keyword::CONNECTION) => {
|
||||
self.expect_keyword_is(Keyword::LIMIT)?;
|
||||
self.expect_keyword(Keyword::LIMIT)?;
|
||||
RoleOption::ConnectionLimit(Expr::Value(self.parse_number_value()?))
|
||||
}
|
||||
Some(Keyword::CREATEDB) => RoleOption::CreateDB(true),
|
||||
|
|
@ -297,7 +256,7 @@ impl Parser<'_> {
|
|||
Some(Keyword::SUPERUSER) => RoleOption::SuperUser(true),
|
||||
Some(Keyword::NOSUPERUSER) => RoleOption::SuperUser(false),
|
||||
Some(Keyword::VALID) => {
|
||||
self.expect_keyword_is(Keyword::UNTIL)?;
|
||||
self.expect_keyword(Keyword::UNTIL)?;
|
||||
RoleOption::ValidUntil(Expr::Value(self.parse_value()?))
|
||||
}
|
||||
_ => self.expected("option", self.peek_token())?,
|
||||
|
|
|
|||
7720
src/parser/mod.rs
7720
src/parser/mod.rs
File diff suppressed because it is too large
Load diff
|
|
@ -33,7 +33,7 @@ use core::fmt::Debug;
|
|||
|
||||
use crate::dialect::*;
|
||||
use crate::parser::{Parser, ParserError};
|
||||
use crate::tokenizer::{Token, Tokenizer};
|
||||
use crate::tokenizer::Tokenizer;
|
||||
use crate::{ast::*, parser::ParserOptions};
|
||||
|
||||
#[cfg(test)]
|
||||
|
|
@ -151,11 +151,10 @@ 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);
|
||||
|
||||
if !canonical.is_empty() && sql != canonical {
|
||||
assert_eq!(self.parse_sql_statements(canonical).unwrap(), statements);
|
||||
}
|
||||
|
|
@ -168,24 +167,6 @@ 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 {
|
||||
|
|
@ -257,22 +238,6 @@ 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.
|
||||
|
|
@ -345,12 +310,10 @@ 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"),
|
||||
|
|
@ -366,11 +329,6 @@ 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),
|
||||
|
|
@ -380,37 +338,19 @@ pub fn table_alias(name: impl Into<String>) -> Option<TableAlias> {
|
|||
|
||||
pub fn table(name: impl Into<String>) -> TableFactor {
|
||||
TableFactor::Table {
|
||||
name: ObjectName::from(vec![Ident::new(name.into())]),
|
||||
name: ObjectName(vec![Ident::new(name.into())]),
|
||||
alias: None,
|
||||
args: None,
|
||||
with_hints: vec![],
|
||||
version: None,
|
||||
partitions: vec![],
|
||||
with_ordinality: false,
|
||||
json_path: None,
|
||||
sample: None,
|
||||
index_hints: vec![],
|
||||
}
|
||||
}
|
||||
|
||||
pub fn table_from_name(name: ObjectName) -> TableFactor {
|
||||
TableFactor::Table {
|
||||
name,
|
||||
alias: None,
|
||||
args: None,
|
||||
with_hints: vec![],
|
||||
version: None,
|
||||
partitions: vec![],
|
||||
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::from(vec![Ident::new(name)]),
|
||||
name: ObjectName(vec![Ident::new(name)]),
|
||||
alias: Some(TableAlias {
|
||||
name: Ident::new(alias),
|
||||
columns: vec![],
|
||||
|
|
@ -420,9 +360,6 @@ pub fn table_with_alias(name: impl Into<String>, alias: impl Into<String>) -> Ta
|
|||
version: None,
|
||||
partitions: vec![],
|
||||
with_ordinality: false,
|
||||
json_path: None,
|
||||
sample: None,
|
||||
index_hints: vec![],
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -430,14 +367,13 @@ pub fn join(relation: TableFactor) -> Join {
|
|||
Join {
|
||||
relation,
|
||||
global: false,
|
||||
join_operator: JoinOperator::Join(JoinConstraint::Natural),
|
||||
join_operator: JoinOperator::Inner(JoinConstraint::Natural),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn call(function: &str, args: impl IntoIterator<Item = Expr>) -> Expr {
|
||||
Expr::Function(Function {
|
||||
name: ObjectName::from(vec![Ident::new(function)]),
|
||||
uses_odbc_syntax: false,
|
||||
name: ObjectName(vec![Ident::new(function)]),
|
||||
parameters: FunctionArguments::None,
|
||||
args: FunctionArguments::List(FunctionArgumentList {
|
||||
duplicate_treatment: None,
|
||||
|
|
@ -453,52 +389,3 @@ 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:?}"),
|
||||
}
|
||||
}
|
||||
|
|
|
|||
1427
src/tokenizer.rs
1427
src/tokenizer.rs
File diff suppressed because it is too large
Load diff
|
|
@ -1,414 +0,0 @@
|
|||
// 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()
|
||||
);
|
||||
}
|
||||
File diff suppressed because it is too large
Load diff
|
|
@ -21,14 +21,12 @@
|
|||
#[macro_use]
|
||||
mod test_utils;
|
||||
|
||||
use helpers::attached_token::AttachedToken;
|
||||
use sqlparser::tokenizer::Span;
|
||||
use test_utils::*;
|
||||
|
||||
use sqlparser::ast::Expr::{BinaryOp, Identifier};
|
||||
use sqlparser::ast::Expr::{BinaryOp, Identifier, MapAccess};
|
||||
use sqlparser::ast::SelectItem::UnnamedExpr;
|
||||
use sqlparser::ast::TableFactor::Table;
|
||||
use sqlparser::ast::Value::Boolean;
|
||||
use sqlparser::ast::Value::Number;
|
||||
use sqlparser::ast::*;
|
||||
use sqlparser::dialect::ClickHouseDialect;
|
||||
use sqlparser::dialect::GenericDialect;
|
||||
|
|
@ -41,28 +39,35 @@ fn parse_map_access_expr() {
|
|||
assert_eq!(
|
||||
Select {
|
||||
distinct: None,
|
||||
select_token: AttachedToken::empty(),
|
||||
top: None,
|
||||
top_before_distinct: false,
|
||||
projection: vec![UnnamedExpr(Expr::CompoundFieldAccess {
|
||||
root: Box::new(Identifier(Ident {
|
||||
projection: vec![UnnamedExpr(MapAccess {
|
||||
column: Box::new(Identifier(Ident {
|
||||
value: "string_values".to_string(),
|
||||
quote_style: None,
|
||||
span: Span::empty(),
|
||||
})),
|
||||
access_chain: vec![AccessExpr::Subscript(Subscript::Index {
|
||||
index: call(
|
||||
keys: vec![MapAccessKey {
|
||||
key: call(
|
||||
"indexOf",
|
||||
[
|
||||
Expr::Identifier(Ident::new("string_names")),
|
||||
Expr::value(Value::SingleQuotedString("endpoint".to_string()))
|
||||
Expr::Value(Value::SingleQuotedString("endpoint".to_string()))
|
||||
]
|
||||
),
|
||||
})],
|
||||
syntax: MapAccessSyntax::Bracket
|
||||
}],
|
||||
})],
|
||||
into: None,
|
||||
from: vec![TableWithJoins {
|
||||
relation: table_from_name(ObjectName::from(vec![Ident::new("foos")])),
|
||||
relation: Table {
|
||||
name: ObjectName(vec![Ident::new("foos")]),
|
||||
alias: None,
|
||||
args: None,
|
||||
with_hints: vec![],
|
||||
version: None,
|
||||
partitions: vec![],
|
||||
with_ordinality: false,
|
||||
},
|
||||
joins: vec![],
|
||||
}],
|
||||
lateral_views: vec![],
|
||||
|
|
@ -71,24 +76,25 @@ 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 {
|
||||
left: Box::new(Expr::CompoundFieldAccess {
|
||||
root: Box::new(Identifier(Ident::new("string_value"))),
|
||||
access_chain: vec![AccessExpr::Subscript(Subscript::Index {
|
||||
index: call(
|
||||
left: Box::new(MapAccess {
|
||||
column: Box::new(Identifier(Ident::new("string_value"))),
|
||||
keys: vec![MapAccessKey {
|
||||
key: call(
|
||||
"indexOf",
|
||||
[
|
||||
Expr::Identifier(Ident::new("string_name")),
|
||||
Expr::value(Value::SingleQuotedString("app".to_string()))
|
||||
Expr::Value(Value::SingleQuotedString("app".to_string()))
|
||||
]
|
||||
),
|
||||
})],
|
||||
syntax: MapAccessSyntax::Bracket
|
||||
}],
|
||||
}),
|
||||
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,7 +107,6 @@ fn parse_map_access_expr() {
|
|||
qualify: None,
|
||||
value_table_mode: None,
|
||||
connect_by: None,
|
||||
flavor: SelectFlavor::Standard,
|
||||
},
|
||||
select
|
||||
);
|
||||
|
|
@ -114,8 +119,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,
|
||||
}),
|
||||
|
|
@ -165,12 +170,10 @@ fn parse_delimited_identifiers() {
|
|||
args,
|
||||
with_hints,
|
||||
version,
|
||||
..
|
||||
with_ordinality: _,
|
||||
partitions: _,
|
||||
} => {
|
||||
assert_eq!(
|
||||
ObjectName::from(vec![Ident::with_quote('"', "a table")]),
|
||||
name
|
||||
);
|
||||
assert_eq!(vec![Ident::with_quote('"', "a table")], name.0);
|
||||
assert_eq!(Ident::with_quote('"', "alias"), alias.unwrap().name);
|
||||
assert!(args.is_none());
|
||||
assert!(with_hints.is_empty());
|
||||
|
|
@ -189,8 +192,7 @@ fn parse_delimited_identifiers() {
|
|||
);
|
||||
assert_eq!(
|
||||
&Expr::Function(Function {
|
||||
name: ObjectName::from(vec![Ident::with_quote('"', "myfun")]),
|
||||
uses_odbc_syntax: false,
|
||||
name: ObjectName(vec![Ident::with_quote('"', "myfun")]),
|
||||
parameters: FunctionArguments::None,
|
||||
args: FunctionArguments::List(FunctionArgumentList {
|
||||
duplicate_treatment: None,
|
||||
|
|
@ -219,21 +221,11 @@ 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",
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse_insert_into_function() {
|
||||
clickhouse().verified_stmt(r#"INSERT INTO TABLE FUNCTION remote('localhost', default.simple_table) VALUES (100, 'inserted via remote()')"#);
|
||||
clickhouse().verified_stmt(r#"INSERT INTO FUNCTION remote('localhost', default.simple_table) VALUES (100, 'inserted via remote()')"#);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -310,7 +302,7 @@ fn parse_alter_table_add_projection() {
|
|||
Statement::AlterTable {
|
||||
name, operations, ..
|
||||
} => {
|
||||
assert_eq!(name, ObjectName::from(vec!["t0".into()]));
|
||||
assert_eq!(name, ObjectName(vec!["t0".into()]));
|
||||
assert_eq!(1, operations.len());
|
||||
assert_eq!(
|
||||
operations[0],
|
||||
|
|
@ -327,14 +319,12 @@ fn parse_alter_table_add_projection() {
|
|||
vec![]
|
||||
)),
|
||||
order_by: Some(OrderBy {
|
||||
kind: OrderByKind::Expressions(vec![OrderByExpr {
|
||||
exprs: vec![OrderByExpr {
|
||||
expr: Identifier(Ident::new("b")),
|
||||
options: OrderByOptions {
|
||||
asc: None,
|
||||
nulls_first: None,
|
||||
},
|
||||
asc: None,
|
||||
nulls_first: None,
|
||||
with_fill: None,
|
||||
}]),
|
||||
}],
|
||||
interpolate: None,
|
||||
}),
|
||||
}
|
||||
|
|
@ -382,7 +372,7 @@ fn parse_alter_table_drop_projection() {
|
|||
Statement::AlterTable {
|
||||
name, operations, ..
|
||||
} => {
|
||||
assert_eq!(name, ObjectName::from(vec!["t0".into()]));
|
||||
assert_eq!(name, ObjectName(vec!["t0".into()]));
|
||||
assert_eq!(1, operations.len());
|
||||
assert_eq!(
|
||||
operations[0],
|
||||
|
|
@ -415,7 +405,7 @@ fn parse_alter_table_clear_and_materialize_projection() {
|
|||
Statement::AlterTable {
|
||||
name, operations, ..
|
||||
} => {
|
||||
assert_eq!(name, ObjectName::from(vec!["t0".into()]));
|
||||
assert_eq!(name, ObjectName(vec!["t0".into()]));
|
||||
assert_eq!(1, operations.len());
|
||||
assert_eq!(
|
||||
operations[0],
|
||||
|
|
@ -534,6 +524,7 @@ fn column_def(name: Ident, data_type: DataType) -> ColumnDef {
|
|||
ColumnDef {
|
||||
name,
|
||||
data_type,
|
||||
collation: None,
|
||||
options: vec![],
|
||||
}
|
||||
}
|
||||
|
|
@ -558,7 +549,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::from(vec!["table".into()]));
|
||||
assert_eq!(name, ObjectName(vec!["table".into()]));
|
||||
assert_eq!(
|
||||
columns,
|
||||
vec![
|
||||
|
|
@ -593,13 +584,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::from(vec!["table".into()]));
|
||||
assert_eq!(name, ObjectName(vec!["table".into()]));
|
||||
assert_eq!(
|
||||
columns,
|
||||
vec![
|
||||
|
|
@ -622,6 +613,7 @@ fn parse_create_table_with_nullable() {
|
|||
ColumnDef {
|
||||
name: "d".into(),
|
||||
data_type: DataType::Date32,
|
||||
collation: None,
|
||||
options: vec![ColumnOptionDef {
|
||||
name: None,
|
||||
option: ColumnOption::Null
|
||||
|
|
@ -647,7 +639,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::from(vec!["table".into()]));
|
||||
assert_eq!(name, ObjectName(vec!["table".into()]));
|
||||
assert_eq!(
|
||||
columns,
|
||||
vec![
|
||||
|
|
@ -665,6 +657,7 @@ fn parse_create_table_with_nested_data_types() {
|
|||
DataType::LowCardinality(Box::new(DataType::String(None)))
|
||||
)
|
||||
]),
|
||||
collation: None,
|
||||
options: vec![],
|
||||
},
|
||||
ColumnDef {
|
||||
|
|
@ -673,16 +666,15 @@ fn parse_create_table_with_nested_data_types() {
|
|||
DataType::Tuple(vec![
|
||||
StructField {
|
||||
field_name: None,
|
||||
field_type: DataType::FixedString(128),
|
||||
options: None,
|
||||
field_type: DataType::FixedString(128)
|
||||
},
|
||||
StructField {
|
||||
field_name: None,
|
||||
field_type: DataType::Int128,
|
||||
options: None,
|
||||
field_type: DataType::Int128
|
||||
}
|
||||
])
|
||||
))),
|
||||
collation: None,
|
||||
options: vec![],
|
||||
},
|
||||
ColumnDef {
|
||||
|
|
@ -691,16 +683,15 @@ 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 {
|
||||
|
|
@ -709,6 +700,7 @@ fn parse_create_table_with_nested_data_types() {
|
|||
Box::new(DataType::String(None)),
|
||||
Box::new(DataType::UInt16)
|
||||
),
|
||||
collation: None,
|
||||
options: vec![],
|
||||
},
|
||||
]
|
||||
|
|
@ -722,14 +714,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,
|
||||
table_options,
|
||||
engine,
|
||||
primary_key,
|
||||
order_by,
|
||||
..
|
||||
|
|
@ -740,35 +732,30 @@ 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
|
||||
);
|
||||
|
||||
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![
|
||||
assert_eq!(
|
||||
engine,
|
||||
Some(TableEngine {
|
||||
name: "SharedMergeTree".to_string(),
|
||||
parameters: Some(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::from(vec![Ident::new(name)]));
|
||||
assert_eq!(actual.name, ObjectName(vec![Ident::new(name)]));
|
||||
assert_eq!(
|
||||
actual.args,
|
||||
FunctionArguments::List(FunctionArgumentList {
|
||||
|
|
@ -813,7 +800,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, .. }) => {
|
||||
|
|
@ -823,11 +810,11 @@ 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::from(vec![Ident::new("now")]),
|
||||
uses_odbc_syntax: false,
|
||||
name: ObjectName(vec![Ident::new("now")]),
|
||||
args: FunctionArguments::List(FunctionArgumentList {
|
||||
args: vec![],
|
||||
duplicate_treatment: None,
|
||||
|
|
@ -844,11 +831,11 @@ 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::from(vec![Ident::new("now")]),
|
||||
uses_odbc_syntax: false,
|
||||
name: ObjectName(vec![Ident::new("now")]),
|
||||
args: FunctionArguments::List(FunctionArgumentList {
|
||||
args: vec![],
|
||||
duplicate_treatment: None,
|
||||
|
|
@ -865,6 +852,7 @@ 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)
|
||||
|
|
@ -873,11 +861,11 @@ 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::from(vec![Ident::new("toString")]),
|
||||
uses_odbc_syntax: false,
|
||||
name: ObjectName(vec![Ident::new("toString")]),
|
||||
args: FunctionArguments::List(FunctionArgumentList {
|
||||
args: vec![FunctionArg::Unnamed(FunctionArgExpr::Expr(
|
||||
Identifier(Ident::new("c"))
|
||||
|
|
@ -904,33 +892,31 @@ 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::from(vec!["v".into()]));
|
||||
assert_eq!(name, ObjectName(vec!["v".into()]));
|
||||
assert_eq!(
|
||||
columns,
|
||||
vec![
|
||||
ViewColumnDef {
|
||||
name: "i".into(),
|
||||
data_type: Some(DataType::Custom(
|
||||
ObjectName::from(vec![Ident {
|
||||
ObjectName(vec![Ident {
|
||||
value: "int".into(),
|
||||
quote_style: Some('"'),
|
||||
span: Span::empty(),
|
||||
quote_style: Some('"')
|
||||
}]),
|
||||
vec![]
|
||||
)),
|
||||
options: None,
|
||||
options: None
|
||||
},
|
||||
ViewColumnDef {
|
||||
name: "f".into(),
|
||||
data_type: Some(DataType::Custom(
|
||||
ObjectName::from(vec![Ident {
|
||||
ObjectName(vec![Ident {
|
||||
value: "String".into(),
|
||||
quote_style: Some('"'),
|
||||
span: Span::empty(),
|
||||
quote_style: Some('"')
|
||||
}]),
|
||||
vec![]
|
||||
)),
|
||||
options: None,
|
||||
options: None
|
||||
},
|
||||
]
|
||||
);
|
||||
|
|
@ -959,113 +945,42 @@ 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() {
|
||||
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!(),
|
||||
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)
|
||||
},
|
||||
])
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
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);
|
||||
_ => unreachable!(),
|
||||
}
|
||||
|
||||
let invalid_cases = vec![
|
||||
("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: (",
|
||||
),
|
||||
"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",
|
||||
];
|
||||
for (sql, error_msg) in invalid_cases {
|
||||
assert_eq!(
|
||||
clickhouse_and_generic()
|
||||
.parse_sql_statements(sql)
|
||||
.unwrap_err(),
|
||||
ParserError(error_msg.to_string())
|
||||
);
|
||||
for sql in invalid_cases {
|
||||
clickhouse_and_generic()
|
||||
.parse_sql_statements(sql)
|
||||
.expect_err("Expected: SETTINGS key = value, found: ");
|
||||
}
|
||||
}
|
||||
#[test]
|
||||
|
|
@ -1102,15 +1017,17 @@ 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)).with_empty_span()
|
||||
)))
|
||||
FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::Value(Value::Number(
|
||||
"0.5".parse().unwrap(),
|
||||
false
|
||||
))))
|
||||
);
|
||||
assert_eq!(
|
||||
parameters.args[1],
|
||||
FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::Value(
|
||||
(Value::Number("0.6".parse().unwrap(), false)).with_empty_span()
|
||||
)))
|
||||
FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::Value(Value::Number(
|
||||
"0.6".parse().unwrap(),
|
||||
false
|
||||
))))
|
||||
);
|
||||
}
|
||||
_ => unreachable!(),
|
||||
|
|
@ -1143,6 +1060,61 @@ 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 \
|
||||
|
|
@ -1154,53 +1126,42 @@ fn parse_select_order_by_with_fill_interpolate() {
|
|||
let select = clickhouse().verified_query(sql);
|
||||
assert_eq!(
|
||||
OrderBy {
|
||||
kind: OrderByKind::Expressions(vec![
|
||||
exprs: vec![
|
||||
OrderByExpr {
|
||||
expr: Expr::Identifier(Ident::new("fname")),
|
||||
options: OrderByOptions {
|
||||
asc: Some(true),
|
||||
nulls_first: Some(true),
|
||||
},
|
||||
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")),
|
||||
options: OrderByOptions {
|
||||
asc: Some(false),
|
||||
nulls_first: Some(false),
|
||||
},
|
||||
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!(
|
||||
select.limit_clause,
|
||||
Some(LimitClause::LimitOffset {
|
||||
limit: Some(Expr::value(number("2"))),
|
||||
offset: None,
|
||||
limit_by: vec![]
|
||||
})
|
||||
);
|
||||
assert_eq!(Some(Expr::Value(number("2"))), select.limit);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -1241,15 +1202,11 @@ 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"))),
|
||||
})
|
||||
.as_ref(),
|
||||
match select.order_by.expect("ORDER BY expected").kind {
|
||||
OrderByKind::Expressions(ref exprs) => exprs[0].with_fill.as_ref(),
|
||||
_ => None,
|
||||
}
|
||||
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
|
||||
);
|
||||
}
|
||||
|
||||
|
|
@ -1284,7 +1241,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 {
|
||||
|
|
@ -1296,17 +1253,12 @@ 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"))),
|
||||
}),
|
||||
},
|
||||
])
|
||||
})
|
||||
.as_ref(),
|
||||
select
|
||||
.order_by
|
||||
.expect("ORDER BY expected")
|
||||
.interpolate
|
||||
.as_ref()
|
||||
}),
|
||||
select.order_by.expect("ORDER BY expected").interpolate
|
||||
);
|
||||
}
|
||||
|
||||
|
|
@ -1315,12 +1267,8 @@ 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 }).as_ref(),
|
||||
select
|
||||
.order_by
|
||||
.expect("ORDER BY expected")
|
||||
.interpolate
|
||||
.as_ref()
|
||||
Some(Interpolate { exprs: None }),
|
||||
select.order_by.expect("ORDER BY expected").interpolate
|
||||
);
|
||||
}
|
||||
|
||||
|
|
@ -1331,13 +1279,8 @@ fn parse_interpolate_with_empty_body() {
|
|||
assert_eq!(
|
||||
Some(Interpolate {
|
||||
exprs: Some(vec![])
|
||||
})
|
||||
.as_ref(),
|
||||
select
|
||||
.order_by
|
||||
.expect("ORDER BY expected")
|
||||
.interpolate
|
||||
.as_ref()
|
||||
}),
|
||||
select.order_by.expect("ORDER BY expected").interpolate
|
||||
);
|
||||
}
|
||||
|
||||
|
|
@ -1351,9 +1294,7 @@ 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)).with_empty_span()
|
||||
)),
|
||||
right: Box::new(Expr::Value(Value::Number("1".parse().unwrap(), false))),
|
||||
})
|
||||
);
|
||||
let selection = query.as_ref().body.as_select().unwrap().selection.as_ref();
|
||||
|
|
@ -1362,9 +1303,7 @@ 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)).with_empty_span()
|
||||
)),
|
||||
right: Box::new(Expr::Value(Value::Number("2".parse().unwrap(), false))),
|
||||
})
|
||||
);
|
||||
}
|
||||
|
|
@ -1380,17 +1319,13 @@ 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)).with_empty_span()
|
||||
)),
|
||||
right: Box::new(Expr::Value(Value::Number("1".parse().unwrap(), false))),
|
||||
}),
|
||||
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)).with_empty_span()
|
||||
)),
|
||||
right: Box::new(Expr::Value(Value::Number("2".parse().unwrap(), false))),
|
||||
}),
|
||||
})
|
||||
);
|
||||
|
|
@ -1414,16 +1349,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::from(vec![Ident::new(
|
||||
clickhouse().verified_stmt(&format!("USE {}", object_name)),
|
||||
Statement::Use(Use::Object(ObjectName(vec![Ident::new(
|
||||
object_name.to_string()
|
||||
)])))
|
||||
);
|
||||
for "e in "e_styles {
|
||||
// Test single identifier with different type of quotes
|
||||
assert_eq!(
|
||||
clickhouse().verified_stmt(&format!("USE {quote}{object_name}{quote}")),
|
||||
Statement::Use(Use::Object(ObjectName::from(vec![Ident::with_quote(
|
||||
clickhouse().verified_stmt(&format!("USE {0}{1}{0}", quote, object_name)),
|
||||
Statement::Use(Use::Object(ObjectName(vec![Ident::with_quote(
|
||||
quote,
|
||||
object_name.to_string(),
|
||||
)])))
|
||||
|
|
@ -1436,7 +1371,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" {
|
||||
|
|
@ -1464,26 +1399,6 @@ fn test_query_with_format_clause() {
|
|||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_insert_query_with_format_clause() {
|
||||
let cases = [
|
||||
r#"INSERT INTO tbl FORMAT JSONEachRow {"id": 1, "value": "foo"}, {"id": 2, "value": "bar"}"#,
|
||||
r#"INSERT INTO tbl FORMAT JSONEachRow ["first", "second", "third"]"#,
|
||||
r#"INSERT INTO tbl FORMAT JSONEachRow [{"first": 1}]"#,
|
||||
r#"INSERT INTO tbl (foo) FORMAT JSONAsObject {"foo": {"bar": {"x": "y"}, "baz": 1}}"#,
|
||||
r#"INSERT INTO tbl (foo, bar) FORMAT JSON {"foo": 1, "bar": 2}"#,
|
||||
r#"INSERT INTO tbl FORMAT CSV col1, col2, col3"#,
|
||||
r#"INSERT INTO tbl FORMAT LineAsString "I love apple", "I love banana", "I love orange""#,
|
||||
r#"INSERT INTO tbl (foo) SETTINGS input_format_json_read_bools_as_numbers = true FORMAT JSONEachRow {"id": 1, "value": "foo"}"#,
|
||||
r#"INSERT INTO tbl SETTINGS format_template_resultset = '/some/path/resultset.format', format_template_row = '/some/path/row.format' FORMAT Template"#,
|
||||
r#"INSERT INTO tbl SETTINGS input_format_json_read_bools_as_numbers = true FORMAT JSONEachRow {"id": 1, "value": "foo"}"#,
|
||||
];
|
||||
|
||||
for sql in &cases {
|
||||
clickhouse().verified_stmt(sql);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse_create_table_on_commit_and_as_query() {
|
||||
let sql = r#"CREATE LOCAL TEMPORARY TABLE test ON COMMIT PRESERVE ROWS AS SELECT 1"#;
|
||||
|
|
@ -1498,9 +1413,10 @@ 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)).with_empty_span()
|
||||
))]
|
||||
vec![UnnamedExpr(Expr::Value(Value::Number(
|
||||
"1".parse().unwrap(),
|
||||
false
|
||||
)))]
|
||||
);
|
||||
}
|
||||
_ => unreachable!(),
|
||||
|
|
@ -1513,9 +1429,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()).with_empty_span(),
|
||||
));
|
||||
let expected_partition = Partition::Expr(Expr::Value(Value::SingleQuotedString(
|
||||
"2024-08-14".to_string(),
|
||||
)));
|
||||
match clickhouse_and_generic().verified_stmt(&sql) {
|
||||
Statement::AlterTable { operations, .. } => {
|
||||
assert_eq!(operations.len(), 1);
|
||||
|
|
@ -1543,9 +1459,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()).with_empty_span(),
|
||||
));
|
||||
let expected_partition = Partition::Expr(Expr::Value(Value::SingleQuotedString(
|
||||
"2024-08-14".to_string(),
|
||||
)));
|
||||
let expected_operation = if operation_name == &"FREEZE" {
|
||||
AlterTableOperation::FreezePartition {
|
||||
partition: expected_partition,
|
||||
|
|
@ -1619,11 +1535,11 @@ fn parse_select_table_function_settings() {
|
|||
settings: Some(vec![
|
||||
Setting {
|
||||
key: "s0".into(),
|
||||
value: Expr::value(number("3")),
|
||||
value: Value::Number("3".parse().unwrap(), false),
|
||||
},
|
||||
Setting {
|
||||
key: "s1".into(),
|
||||
value: Expr::value(single_quoted_string("s")),
|
||||
value: Value::SingleQuotedString("s".into()),
|
||||
},
|
||||
]),
|
||||
},
|
||||
|
|
@ -1644,11 +1560,11 @@ fn parse_select_table_function_settings() {
|
|||
settings: Some(vec![
|
||||
Setting {
|
||||
key: "s0".into(),
|
||||
value: Expr::value(number("3")),
|
||||
value: Value::Number("3".parse().unwrap(), false),
|
||||
},
|
||||
Setting {
|
||||
key: "s1".into(),
|
||||
value: Expr::value(single_quoted_string("s")),
|
||||
value: Value::SingleQuotedString("s".into()),
|
||||
},
|
||||
]),
|
||||
},
|
||||
|
|
@ -1658,6 +1574,7 @@ 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()
|
||||
|
|
@ -1696,14 +1613,6 @@ fn parse_explain_table() {
|
|||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse_table_sample() {
|
||||
clickhouse().verified_stmt("SELECT * FROM tbl SAMPLE 0.1");
|
||||
clickhouse().verified_stmt("SELECT * FROM tbl SAMPLE 1000");
|
||||
clickhouse().verified_stmt("SELECT * FROM tbl SAMPLE 1 / 10");
|
||||
clickhouse().verified_stmt("SELECT * FROM tbl SAMPLE 1 / 10 OFFSET 1 / 2");
|
||||
}
|
||||
|
||||
fn clickhouse() -> TestedDialects {
|
||||
TestedDialects::new(vec![Box::new(ClickHouseDialect {})])
|
||||
}
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -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.with_empty_span())))
|
||||
Some(Ok(Expr::Value(Value::Null)))
|
||||
} else {
|
||||
None
|
||||
}
|
||||
|
|
@ -115,11 +115,7 @@ fn custom_statement_parser() -> Result<(), ParserError> {
|
|||
for _ in 0..3 {
|
||||
let _ = parser.next_token();
|
||||
}
|
||||
Some(Ok(Statement::Commit {
|
||||
chain: false,
|
||||
end: false,
|
||||
modifier: None,
|
||||
}))
|
||||
Some(Ok(Statement::Commit { chain: false }))
|
||||
} else {
|
||||
None
|
||||
}
|
||||
|
|
|
|||
|
|
@ -15,11 +15,9 @@
|
|||
// 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]
|
||||
|
|
@ -49,9 +47,7 @@ fn test_databricks_identifiers() {
|
|||
databricks()
|
||||
.verified_only_select(r#"SELECT "Ä""#)
|
||||
.projection[0],
|
||||
SelectItem::UnnamedExpr(Expr::Value(
|
||||
(Value::DoubleQuotedString("Ä".to_owned())).with_empty_span()
|
||||
))
|
||||
SelectItem::UnnamedExpr(Expr::Value(Value::DoubleQuotedString("Ä".to_owned())))
|
||||
);
|
||||
}
|
||||
|
||||
|
|
@ -66,9 +62,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 {
|
||||
|
|
@ -103,44 +99,40 @@ 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![
|
||||
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(Expr::Identifier(Ident::new("p1"))),
|
||||
op: BinaryOperator::Eq,
|
||||
right: Box::new(Expr::Identifier(Ident::new("p2")))
|
||||
},
|
||||
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"))]
|
||||
))
|
||||
}
|
||||
],
|
||||
else_result: Some(Box::new(Expr::value(number("1"))))
|
||||
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"))))
|
||||
})
|
||||
})
|
||||
]
|
||||
|
|
@ -160,12 +152,12 @@ fn test_values_clause() {
|
|||
explicit_row: false,
|
||||
rows: vec![
|
||||
vec![
|
||||
Expr::Value((Value::DoubleQuotedString("one".to_owned())).with_empty_span()),
|
||||
Expr::value(number("1")),
|
||||
Expr::Value(Value::DoubleQuotedString("one".to_owned())),
|
||||
Expr::Value(number("1")),
|
||||
],
|
||||
vec![
|
||||
Expr::Value((Value::SingleQuotedString("two".to_owned())).with_empty_span()),
|
||||
Expr::value(number("2")),
|
||||
Expr::Value(Value::SingleQuotedString("two".to_owned())),
|
||||
Expr::Value(number("2")),
|
||||
],
|
||||
],
|
||||
};
|
||||
|
|
@ -193,9 +185,15 @@ fn test_values_clause() {
|
|||
"SELECT * FROM values",
|
||||
));
|
||||
assert_eq!(
|
||||
Some(&table_from_name(ObjectName::from(vec![Ident::new(
|
||||
"values"
|
||||
)]))),
|
||||
Some(&TableFactor::Table {
|
||||
name: ObjectName(vec![Ident::new("values")]),
|
||||
alias: None,
|
||||
args: None,
|
||||
with_hints: vec![],
|
||||
version: None,
|
||||
partitions: vec![],
|
||||
with_ordinality: false,
|
||||
}),
|
||||
query
|
||||
.body
|
||||
.as_select()
|
||||
|
|
@ -214,16 +212,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::from(vec![Ident::new(
|
||||
databricks().verified_stmt(&format!("USE {}", object_name)),
|
||||
Statement::Use(Use::Object(ObjectName(vec![Ident::new(
|
||||
object_name.to_string()
|
||||
)])))
|
||||
);
|
||||
for "e in "e_styles {
|
||||
// Test single identifier with different type of quotes
|
||||
assert_eq!(
|
||||
databricks().verified_stmt(&format!("USE {quote}{object_name}{quote}")),
|
||||
Statement::Use(Use::Object(ObjectName::from(vec![Ident::with_quote(
|
||||
databricks().verified_stmt(&format!("USE {0}{1}{0}", quote, object_name)),
|
||||
Statement::Use(Use::Object(ObjectName(vec![Ident::with_quote(
|
||||
quote,
|
||||
object_name.to_string(),
|
||||
)])))
|
||||
|
|
@ -234,22 +232,22 @@ fn parse_use() {
|
|||
for "e in "e_styles {
|
||||
// Test single identifier with keyword and different type of quotes
|
||||
assert_eq!(
|
||||
databricks().verified_stmt(&format!("USE CATALOG {quote}my_catalog{quote}")),
|
||||
Statement::Use(Use::Catalog(ObjectName::from(vec![Ident::with_quote(
|
||||
databricks().verified_stmt(&format!("USE CATALOG {0}my_catalog{0}", quote)),
|
||||
Statement::Use(Use::Catalog(ObjectName(vec![Ident::with_quote(
|
||||
quote,
|
||||
"my_catalog".to_string(),
|
||||
)])))
|
||||
);
|
||||
assert_eq!(
|
||||
databricks().verified_stmt(&format!("USE DATABASE {quote}my_database{quote}")),
|
||||
Statement::Use(Use::Database(ObjectName::from(vec![Ident::with_quote(
|
||||
databricks().verified_stmt(&format!("USE DATABASE {0}my_database{0}", quote)),
|
||||
Statement::Use(Use::Database(ObjectName(vec![Ident::with_quote(
|
||||
quote,
|
||||
"my_database".to_string(),
|
||||
)])))
|
||||
);
|
||||
assert_eq!(
|
||||
databricks().verified_stmt(&format!("USE SCHEMA {quote}my_schema{quote}")),
|
||||
Statement::Use(Use::Schema(ObjectName::from(vec![Ident::with_quote(
|
||||
databricks().verified_stmt(&format!("USE SCHEMA {0}my_schema{0}", quote)),
|
||||
Statement::Use(Use::Schema(ObjectName(vec![Ident::with_quote(
|
||||
quote,
|
||||
"my_schema".to_string(),
|
||||
)])))
|
||||
|
|
@ -259,19 +257,15 @@ 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::from(vec![Ident::new(
|
||||
"my_catalog"
|
||||
)])))
|
||||
Statement::Use(Use::Catalog(ObjectName(vec![Ident::new("my_catalog")])))
|
||||
);
|
||||
assert_eq!(
|
||||
databricks().verified_stmt("USE DATABASE my_schema"),
|
||||
Statement::Use(Use::Database(ObjectName::from(vec![Ident::new(
|
||||
"my_schema"
|
||||
)])))
|
||||
Statement::Use(Use::Database(ObjectName(vec![Ident::new("my_schema")])))
|
||||
);
|
||||
assert_eq!(
|
||||
databricks().verified_stmt("USE SCHEMA my_schema"),
|
||||
Statement::Use(Use::Schema(ObjectName::from(vec![Ident::new("my_schema")])))
|
||||
Statement::Use(Use::Schema(ObjectName(vec![Ident::new("my_schema")])))
|
||||
);
|
||||
|
||||
// Test invalid syntax - missing identifier
|
||||
|
|
@ -283,84 +277,3 @@ fn parse_use() {
|
|||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse_databricks_struct_function() {
|
||||
assert_eq!(
|
||||
databricks_and_generic()
|
||||
.verified_only_select("SELECT STRUCT(1, 'foo')")
|
||||
.projection[0],
|
||||
SelectItem::UnnamedExpr(Expr::Struct {
|
||||
values: vec![
|
||||
Expr::value(number("1")),
|
||||
Expr::Value((Value::SingleQuotedString("foo".to_string())).with_empty_span())
|
||||
],
|
||||
fields: vec![]
|
||||
})
|
||||
);
|
||||
assert_eq!(
|
||||
databricks_and_generic()
|
||||
.verified_only_select("SELECT STRUCT(1 AS one, 'foo' AS foo, false)")
|
||||
.projection[0],
|
||||
SelectItem::UnnamedExpr(Expr::Struct {
|
||||
values: vec![
|
||||
Expr::Named {
|
||||
expr: Expr::value(number("1")).into(),
|
||||
name: Ident::new("one")
|
||||
},
|
||||
Expr::Named {
|
||||
expr: Expr::Value(
|
||||
(Value::SingleQuotedString("foo".to_string())).with_empty_span()
|
||||
)
|
||||
.into(),
|
||||
name: Ident::new("foo")
|
||||
},
|
||||
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:?}"),
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -18,13 +18,10 @@
|
|||
#[macro_use]
|
||||
mod test_utils;
|
||||
|
||||
use helpers::attached_token::AttachedToken;
|
||||
use sqlparser::tokenizer::Span;
|
||||
use test_utils::*;
|
||||
|
||||
use sqlparser::ast::*;
|
||||
use sqlparser::dialect::{DuckDbDialect, GenericDialect};
|
||||
use sqlparser::parser::ParserError;
|
||||
|
||||
fn duckdb() -> TestedDialects {
|
||||
TestedDialects::new(vec![Box::new(DuckDbDialect {})])
|
||||
|
|
@ -45,12 +42,10 @@ 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,
|
||||
|
|
@ -63,6 +58,7 @@ fn test_struct() {
|
|||
vec![ColumnDef {
|
||||
name: "s".into(),
|
||||
data_type: struct_type1.clone(),
|
||||
collation: None,
|
||||
options: vec![],
|
||||
}]
|
||||
);
|
||||
|
|
@ -77,6 +73,7 @@ fn test_struct() {
|
|||
Box::new(struct_type1),
|
||||
None
|
||||
)),
|
||||
collation: None,
|
||||
options: vec![],
|
||||
}]
|
||||
);
|
||||
|
|
@ -87,7 +84,6 @@ fn test_struct() {
|
|||
StructField {
|
||||
field_name: Some(Ident::new("v")),
|
||||
field_type: DataType::Varchar(None),
|
||||
options: None,
|
||||
},
|
||||
StructField {
|
||||
field_name: Some(Ident::new("s")),
|
||||
|
|
@ -96,17 +92,14 @@ 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,
|
||||
|
|
@ -125,6 +118,7 @@ fn test_struct() {
|
|||
Box::new(struct_type2),
|
||||
None
|
||||
)),
|
||||
collation: None,
|
||||
options: vec![],
|
||||
}]
|
||||
);
|
||||
|
|
@ -164,7 +158,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(
|
||||
SelectItemQualifiedWildcardKind::ObjectName(ObjectName::from(vec![Ident::new("name")])),
|
||||
ObjectName(vec![Ident::new("name")]),
|
||||
WildcardAdditionalOptions {
|
||||
opt_exclude: Some(ExcludeSelectItem::Single(Ident::new("department_id"))),
|
||||
..Default::default()
|
||||
|
|
@ -195,7 +189,7 @@ fn test_create_macro() {
|
|||
let expected = Statement::CreateMacro {
|
||||
or_replace: false,
|
||||
temporary: false,
|
||||
name: ObjectName::from(vec![Ident::new("schema"), Ident::new("add")]),
|
||||
name: ObjectName(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"))),
|
||||
|
|
@ -212,12 +206,12 @@ fn test_create_macro_default_args() {
|
|||
let expected = Statement::CreateMacro {
|
||||
or_replace: false,
|
||||
temporary: false,
|
||||
name: ObjectName::from(vec![Ident::new("add_default")]),
|
||||
name: ObjectName(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 {
|
||||
|
|
@ -240,7 +234,7 @@ fn test_create_table_macro() {
|
|||
let expected = Statement::CreateMacro {
|
||||
or_replace: true,
|
||||
temporary: true,
|
||||
name: ObjectName::from(vec![Ident::new("dynamic_table")]),
|
||||
name: ObjectName(vec![Ident::new("dynamic_table")]),
|
||||
args: Some(vec![
|
||||
MacroArg::new("col1_value"),
|
||||
MacroArg::new("col2_value"),
|
||||
|
|
@ -265,18 +259,30 @@ fn test_select_union_by_name() {
|
|||
op: SetOperator::Union,
|
||||
set_quantifier: *expected_quantifier,
|
||||
left: Box::<SetExpr>::new(SetExpr::Select(Box::new(Select {
|
||||
select_token: AttachedToken::empty(),
|
||||
distinct: None,
|
||||
top: None,
|
||||
projection: vec![SelectItem::Wildcard(WildcardAdditionalOptions::default())],
|
||||
top_before_distinct: false,
|
||||
projection: vec![SelectItem::Wildcard(WildcardAdditionalOptions {
|
||||
opt_ilike: None,
|
||||
opt_exclude: None,
|
||||
opt_except: None,
|
||||
opt_rename: None,
|
||||
opt_replace: None,
|
||||
})],
|
||||
into: None,
|
||||
from: vec![TableWithJoins {
|
||||
relation: table_from_name(ObjectName::from(vec![Ident {
|
||||
value: "capitals".to_string(),
|
||||
quote_style: None,
|
||||
span: Span::empty(),
|
||||
}])),
|
||||
relation: TableFactor::Table {
|
||||
name: ObjectName(vec![Ident {
|
||||
value: "capitals".to_string(),
|
||||
quote_style: None,
|
||||
}]),
|
||||
alias: None,
|
||||
args: None,
|
||||
with_hints: vec![],
|
||||
version: None,
|
||||
partitions: vec![],
|
||||
with_ordinality: false,
|
||||
},
|
||||
joins: vec![],
|
||||
}],
|
||||
lateral_views: vec![],
|
||||
|
|
@ -292,21 +298,32 @@ 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(),
|
||||
distinct: None,
|
||||
top: None,
|
||||
projection: vec![SelectItem::Wildcard(WildcardAdditionalOptions::default())],
|
||||
top_before_distinct: false,
|
||||
projection: vec![SelectItem::Wildcard(WildcardAdditionalOptions {
|
||||
opt_ilike: None,
|
||||
opt_exclude: None,
|
||||
opt_except: None,
|
||||
opt_rename: None,
|
||||
opt_replace: None,
|
||||
})],
|
||||
into: None,
|
||||
from: vec![TableWithJoins {
|
||||
relation: table_from_name(ObjectName::from(vec![Ident {
|
||||
value: "weather".to_string(),
|
||||
quote_style: None,
|
||||
span: Span::empty(),
|
||||
}])),
|
||||
relation: TableFactor::Table {
|
||||
name: ObjectName(vec![Ident {
|
||||
value: "weather".to_string(),
|
||||
quote_style: None,
|
||||
}]),
|
||||
alias: None,
|
||||
args: None,
|
||||
with_hints: vec![],
|
||||
version: None,
|
||||
partitions: vec![],
|
||||
with_ordinality: false,
|
||||
},
|
||||
joins: vec![],
|
||||
}],
|
||||
lateral_views: vec![],
|
||||
|
|
@ -322,7 +339,6 @@ fn test_select_union_by_name() {
|
|||
qualify: None,
|
||||
value_table_mode: None,
|
||||
connect_by: None,
|
||||
flavor: SelectFlavor::Standard,
|
||||
}))),
|
||||
});
|
||||
assert_eq!(ast.body, expected);
|
||||
|
|
@ -337,8 +353,7 @@ fn test_duckdb_install() {
|
|||
Statement::Install {
|
||||
extension_name: Ident {
|
||||
value: "tpch".to_string(),
|
||||
quote_style: None,
|
||||
span: Span::empty()
|
||||
quote_style: None
|
||||
}
|
||||
}
|
||||
);
|
||||
|
|
@ -351,40 +366,13 @@ fn test_duckdb_load_extension() {
|
|||
Statement::Load {
|
||||
extension_name: Ident {
|
||||
value: "my_extension".to_string(),
|
||||
quote_style: None,
|
||||
span: Span::empty()
|
||||
quote_style: None
|
||||
}
|
||||
},
|
||||
stmt
|
||||
);
|
||||
}
|
||||
|
||||
#[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
|
||||
|
|
@ -396,15 +384,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])
|
||||
|
|
@ -414,9 +402,7 @@ 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())).with_empty_span()
|
||||
)),
|
||||
value: Box::new(Expr::Value(Value::SingleQuotedString("abc".to_string()))),
|
||||
},],)],
|
||||
named: false
|
||||
}),
|
||||
|
|
@ -426,7 +412,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"),
|
||||
|
|
@ -445,14 +431,11 @@ 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())).with_empty_span()
|
||||
)
|
||||
.into(),
|
||||
value: Expr::Value(Value::SingleQuotedString("abc".to_string())).into(),
|
||||
},
|
||||
],),
|
||||
expr_from_projection(&select.projection[3])
|
||||
|
|
@ -469,7 +452,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(),
|
||||
}],),
|
||||
|
|
@ -624,24 +607,23 @@ 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::from(vec![Ident::new("FUN")]),
|
||||
uses_odbc_syntax: false,
|
||||
name: ObjectName(vec![Ident::new("FUN")]),
|
||||
parameters: FunctionArguments::None,
|
||||
args: FunctionArguments::List(FunctionArgumentList {
|
||||
duplicate_treatment: None,
|
||||
args: vec![
|
||||
FunctionArg::Named {
|
||||
name: Ident::new("a"),
|
||||
arg: FunctionArgExpr::Expr(Expr::Value(
|
||||
(Value::SingleQuotedString("1".to_owned())).with_empty_span()
|
||||
)),
|
||||
arg: FunctionArgExpr::Expr(Expr::Value(Value::SingleQuotedString(
|
||||
"1".to_owned()
|
||||
))),
|
||||
operator: FunctionArgOperator::Assignment
|
||||
},
|
||||
FunctionArg::Named {
|
||||
name: Ident::new("b"),
|
||||
arg: FunctionArgExpr::Expr(Expr::Value(
|
||||
(Value::SingleQuotedString("2".to_owned())).with_empty_span()
|
||||
)),
|
||||
arg: FunctionArgExpr::Expr(Expr::Value(Value::SingleQuotedString(
|
||||
"2".to_owned()
|
||||
))),
|
||||
operator: FunctionArgOperator::Assignment
|
||||
},
|
||||
],
|
||||
|
|
@ -667,18 +649,18 @@ fn test_array_index() {
|
|||
_ => panic!("Expected an expression with alias"),
|
||||
};
|
||||
assert_eq!(
|
||||
&Expr::CompoundFieldAccess {
|
||||
root: Box::new(Expr::Array(Array {
|
||||
&Expr::Subscript {
|
||||
expr: Box::new(Expr::Array(Array {
|
||||
elem: vec![
|
||||
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())
|
||||
Expr::Value(Value::SingleQuotedString("a".to_owned())),
|
||||
Expr::Value(Value::SingleQuotedString("b".to_owned())),
|
||||
Expr::Value(Value::SingleQuotedString("c".to_owned()))
|
||||
],
|
||||
named: false
|
||||
})),
|
||||
access_chain: vec![AccessExpr::Subscript(Subscript::Index {
|
||||
index: Expr::value(number("3"))
|
||||
})]
|
||||
subscript: Box::new(Subscript::Index {
|
||||
index: Expr::Value(number("3"))
|
||||
})
|
||||
},
|
||||
expr
|
||||
);
|
||||
|
|
@ -697,8 +679,7 @@ fn test_duckdb_union_datatype() {
|
|||
if_not_exists: Default::default(),
|
||||
transient: Default::default(),
|
||||
volatile: Default::default(),
|
||||
iceberg: Default::default(),
|
||||
name: ObjectName::from(vec!["tbl1".into()]),
|
||||
name: ObjectName(vec!["tbl1".into()]),
|
||||
columns: vec![
|
||||
ColumnDef {
|
||||
name: "one".into(),
|
||||
|
|
@ -706,6 +687,7 @@ fn test_duckdb_union_datatype() {
|
|||
field_name: "a".into(),
|
||||
field_type: DataType::Int(None)
|
||||
}]),
|
||||
collation: Default::default(),
|
||||
options: Default::default()
|
||||
},
|
||||
ColumnDef {
|
||||
|
|
@ -720,6 +702,7 @@ fn test_duckdb_union_datatype() {
|
|||
field_type: DataType::Int(None)
|
||||
}
|
||||
]),
|
||||
collation: Default::default(),
|
||||
options: Default::default()
|
||||
},
|
||||
ColumnDef {
|
||||
|
|
@ -731,6 +714,7 @@ fn test_duckdb_union_datatype() {
|
|||
field_type: DataType::Int(None)
|
||||
}])
|
||||
}]),
|
||||
collation: Default::default(),
|
||||
options: Default::default()
|
||||
}
|
||||
],
|
||||
|
|
@ -742,13 +726,19 @@ 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(),
|
||||
|
|
@ -756,7 +746,7 @@ fn test_duckdb_union_datatype() {
|
|||
partition_by: Default::default(),
|
||||
cluster_by: Default::default(),
|
||||
clustered_by: Default::default(),
|
||||
inherits: Default::default(),
|
||||
options: Default::default(),
|
||||
strict: Default::default(),
|
||||
copy_grants: Default::default(),
|
||||
enable_schema_evolution: Default::default(),
|
||||
|
|
@ -766,13 +756,7 @@ 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(),
|
||||
base_location: Default::default(),
|
||||
external_volume: Default::default(),
|
||||
catalog: Default::default(),
|
||||
catalog_sync: Default::default(),
|
||||
storage_serialization_policy: Default::default(),
|
||||
table_options: CreateTableOptions::None
|
||||
with_tags: Default::default()
|
||||
}),
|
||||
stmt
|
||||
);
|
||||
|
|
@ -793,16 +777,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::from(vec![Ident::new(
|
||||
duckdb().verified_stmt(&format!("USE {}", object_name)),
|
||||
Statement::Use(Use::Object(ObjectName(vec![Ident::new(
|
||||
object_name.to_string()
|
||||
)])))
|
||||
);
|
||||
for "e in "e_styles {
|
||||
// Test single identifier with different type of quotes
|
||||
assert_eq!(
|
||||
duckdb().verified_stmt(&format!("USE {quote}{object_name}{quote}")),
|
||||
Statement::Use(Use::Object(ObjectName::from(vec![Ident::with_quote(
|
||||
duckdb().verified_stmt(&format!("USE {0}{1}{0}", quote, object_name)),
|
||||
Statement::Use(Use::Object(ObjectName(vec![Ident::with_quote(
|
||||
quote,
|
||||
object_name.to_string(),
|
||||
)])))
|
||||
|
|
@ -813,10 +797,8 @@ fn parse_use() {
|
|||
for "e in "e_styles {
|
||||
// Test double identifier with different type of quotes
|
||||
assert_eq!(
|
||||
duckdb().verified_stmt(&format!(
|
||||
"USE {quote}CATALOG{quote}.{quote}my_schema{quote}"
|
||||
)),
|
||||
Statement::Use(Use::Object(ObjectName::from(vec![
|
||||
duckdb().verified_stmt(&format!("USE {0}CATALOG{0}.{0}my_schema{0}", quote)),
|
||||
Statement::Use(Use::Object(ObjectName(vec![
|
||||
Ident::with_quote(quote, "CATALOG"),
|
||||
Ident::with_quote(quote, "my_schema")
|
||||
])))
|
||||
|
|
@ -825,38 +807,9 @@ fn parse_use() {
|
|||
// Test double identifier without quotes
|
||||
assert_eq!(
|
||||
duckdb().verified_stmt("USE mydb.my_schema"),
|
||||
Statement::Use(Use::Object(ObjectName::from(vec![
|
||||
Statement::Use(Use::Object(ObjectName(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()
|
||||
);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -21,11 +21,11 @@
|
|||
//! is also tested (on the inputs it can handle).
|
||||
|
||||
use sqlparser::ast::{
|
||||
ClusteredBy, CommentDef, CreateFunction, CreateFunctionBody, CreateFunctionUsing, CreateTable,
|
||||
Expr, Function, FunctionArgumentList, FunctionArguments, Ident, ObjectName, OrderByExpr,
|
||||
OrderByOptions, SelectItem, Set, Statement, TableFactor, UnaryOperator, Use, Value,
|
||||
ClusteredBy, CommentDef, CreateFunctionBody, CreateFunctionUsing, CreateTable, Expr, Function,
|
||||
FunctionArgumentList, FunctionArguments, Ident, ObjectName, OneOrManyWithParens, OrderByExpr,
|
||||
SelectItem, Statement, TableFactor, UnaryOperator, Use, Value,
|
||||
};
|
||||
use sqlparser::dialect::{AnsiDialect, GenericDialect, HiveDialect};
|
||||
use sqlparser::dialect::{GenericDialect, HiveDialect, MsSqlDialect};
|
||||
use sqlparser::parser::ParserError;
|
||||
use sqlparser::test_utils::*;
|
||||
|
||||
|
|
@ -91,7 +91,7 @@ fn parse_msck() {
|
|||
}
|
||||
|
||||
#[test]
|
||||
fn parse_set_hivevar() {
|
||||
fn parse_set() {
|
||||
let set = "SET HIVEVAR:name = a, b, c_d";
|
||||
hive().verified_stmt(set);
|
||||
}
|
||||
|
|
@ -133,7 +133,9 @@ fn create_table_with_comment() {
|
|||
Statement::CreateTable(CreateTable { comment, .. }) => {
|
||||
assert_eq!(
|
||||
comment,
|
||||
Some(CommentDef::WithoutEq("table comment".to_string()))
|
||||
Some(CommentDef::AfterColumnDefsWithoutEq(
|
||||
"table comment".to_string()
|
||||
))
|
||||
)
|
||||
}
|
||||
_ => unreachable!(),
|
||||
|
|
@ -168,18 +170,14 @@ fn create_table_with_clustered_by() {
|
|||
sorted_by: Some(vec![
|
||||
OrderByExpr {
|
||||
expr: Expr::Identifier(Ident::new("a")),
|
||||
options: OrderByOptions {
|
||||
asc: Some(true),
|
||||
nulls_first: None,
|
||||
},
|
||||
asc: Some(true),
|
||||
nulls_first: None,
|
||||
with_fill: None,
|
||||
},
|
||||
OrderByExpr {
|
||||
expr: Expr::Identifier(Ident::new("b")),
|
||||
options: OrderByOptions {
|
||||
asc: Some(false),
|
||||
nulls_first: None,
|
||||
},
|
||||
asc: Some(false),
|
||||
nulls_first: None,
|
||||
with_fill: None,
|
||||
},
|
||||
]),
|
||||
|
|
@ -341,9 +339,6 @@ 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]
|
||||
|
|
@ -369,20 +364,20 @@ fn from_cte() {
|
|||
fn set_statement_with_minus() {
|
||||
assert_eq!(
|
||||
hive().verified_stmt("SET hive.tez.java.opts = -Xmx4g"),
|
||||
Statement::Set(Set::SingleAssignment {
|
||||
scope: None,
|
||||
Statement::SetVariable {
|
||||
local: false,
|
||||
hivevar: false,
|
||||
variable: ObjectName::from(vec![
|
||||
variables: OneOrManyWithParens::One(ObjectName(vec![
|
||||
Ident::new("hive"),
|
||||
Ident::new("tez"),
|
||||
Ident::new("java"),
|
||||
Ident::new("opts")
|
||||
]),
|
||||
values: vec![Expr::UnaryOp {
|
||||
])),
|
||||
value: vec![Expr::UnaryOp {
|
||||
op: UnaryOperator::Minus,
|
||||
expr: Box::new(Expr::Identifier(Ident::new("Xmx4g")))
|
||||
}],
|
||||
})
|
||||
}
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
|
|
@ -397,20 +392,19 @@ fn set_statement_with_minus() {
|
|||
fn parse_create_function() {
|
||||
let sql = "CREATE TEMPORARY FUNCTION mydb.myfunc AS 'org.random.class.Name' USING JAR 'hdfs://somewhere.com:8020/very/far'";
|
||||
match hive().verified_stmt(sql) {
|
||||
Statement::CreateFunction(CreateFunction {
|
||||
Statement::CreateFunction {
|
||||
temporary,
|
||||
name,
|
||||
function_body,
|
||||
using,
|
||||
..
|
||||
}) => {
|
||||
} => {
|
||||
assert!(temporary);
|
||||
assert_eq!(name.to_string(), "mydb.myfunc");
|
||||
assert_eq!(
|
||||
function_body,
|
||||
Some(CreateFunctionBody::AsBeforeOptions(Expr::Value(
|
||||
(Value::SingleQuotedString("org.random.class.Name".to_string()))
|
||||
.with_empty_span()
|
||||
Value::SingleQuotedString("org.random.class.Name".to_string())
|
||||
)))
|
||||
);
|
||||
assert_eq!(
|
||||
|
|
@ -424,7 +418,7 @@ fn parse_create_function() {
|
|||
}
|
||||
|
||||
// Test error in dialect that doesn't support parsing CREATE FUNCTION
|
||||
let unsupported_dialects = TestedDialects::new(vec![Box::new(AnsiDialect {})]);
|
||||
let unsupported_dialects = TestedDialects::new(vec![Box::new(MsSqlDialect {})]);
|
||||
|
||||
assert_eq!(
|
||||
unsupported_dialects.parse_sql_statements(sql).unwrap_err(),
|
||||
|
|
@ -463,14 +457,8 @@ fn parse_delimited_identifiers() {
|
|||
version,
|
||||
with_ordinality: _,
|
||||
partitions: _,
|
||||
json_path: _,
|
||||
sample: _,
|
||||
index_hints: _,
|
||||
} => {
|
||||
assert_eq!(
|
||||
ObjectName::from(vec![Ident::with_quote('"', "a table")]),
|
||||
name
|
||||
);
|
||||
assert_eq!(vec![Ident::with_quote('"', "a table")], name.0);
|
||||
assert_eq!(Ident::with_quote('"', "alias"), alias.unwrap().name);
|
||||
assert!(args.is_none());
|
||||
assert!(with_hints.is_empty());
|
||||
|
|
@ -489,8 +477,7 @@ fn parse_delimited_identifiers() {
|
|||
);
|
||||
assert_eq!(
|
||||
&Expr::Function(Function {
|
||||
name: ObjectName::from(vec![Ident::with_quote('"', "myfun")]),
|
||||
uses_odbc_syntax: false,
|
||||
name: ObjectName(vec![Ident::with_quote('"', "myfun")]),
|
||||
parameters: FunctionArguments::None,
|
||||
args: FunctionArguments::List(FunctionArgumentList {
|
||||
duplicate_treatment: None,
|
||||
|
|
@ -524,16 +511,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::from(vec![Ident::new(
|
||||
hive().verified_stmt(&format!("USE {}", object_name)),
|
||||
Statement::Use(Use::Object(ObjectName(vec![Ident::new(
|
||||
object_name.to_string()
|
||||
)])))
|
||||
);
|
||||
for "e in "e_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::from(vec![Ident::with_quote(
|
||||
hive().verified_stmt(&format!("USE {}{}{}", quote, object_name, quote)),
|
||||
Statement::Use(Use::Object(ObjectName(vec![Ident::with_quote(
|
||||
quote,
|
||||
object_name.to_string(),
|
||||
)])))
|
||||
|
|
@ -547,15 +534,6 @@ fn parse_use() {
|
|||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_tample_sample() {
|
||||
hive().verified_stmt("SELECT * FROM source TABLESAMPLE (BUCKET 3 OUT OF 32 ON rand()) AS s");
|
||||
hive().verified_stmt("SELECT * FROM source TABLESAMPLE (BUCKET 3 OUT OF 16 ON id)");
|
||||
hive().verified_stmt("SELECT * FROM source TABLESAMPLE (100M) AS s");
|
||||
hive().verified_stmt("SELECT * FROM source TABLESAMPLE (0.1 PERCENT) AS s");
|
||||
hive().verified_stmt("SELECT * FROM source TABLESAMPLE (10 ROWS)");
|
||||
}
|
||||
|
||||
fn hive() -> TestedDialects {
|
||||
TestedDialects::new(vec![Box::new(HiveDialect {})])
|
||||
}
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
File diff suppressed because it is too large
Load diff
File diff suppressed because it is too large
Load diff
|
|
@ -18,7 +18,6 @@
|
|||
#[macro_use]
|
||||
mod test_utils;
|
||||
|
||||
use sqlparser::tokenizer::Span;
|
||||
use test_utils::*;
|
||||
|
||||
use sqlparser::ast::*;
|
||||
|
|
@ -32,25 +31,30 @@ fn test_square_brackets_over_db_schema_table_name() {
|
|||
select.projection[0],
|
||||
SelectItem::UnnamedExpr(Expr::Identifier(Ident {
|
||||
value: "col1".to_string(),
|
||||
quote_style: Some('['),
|
||||
span: Span::empty(),
|
||||
quote_style: Some('[')
|
||||
})),
|
||||
);
|
||||
assert_eq!(
|
||||
select.from[0],
|
||||
TableWithJoins {
|
||||
relation: table_from_name(ObjectName::from(vec![
|
||||
Ident {
|
||||
value: "test_schema".to_string(),
|
||||
quote_style: Some('['),
|
||||
span: Span::empty(),
|
||||
},
|
||||
Ident {
|
||||
value: "test_table".to_string(),
|
||||
quote_style: Some('['),
|
||||
span: Span::empty(),
|
||||
}
|
||||
])),
|
||||
relation: TableFactor::Table {
|
||||
name: ObjectName(vec![
|
||||
Ident {
|
||||
value: "test_schema".to_string(),
|
||||
quote_style: Some('[')
|
||||
},
|
||||
Ident {
|
||||
value: "test_table".to_string(),
|
||||
quote_style: Some('[')
|
||||
}
|
||||
]),
|
||||
alias: None,
|
||||
args: None,
|
||||
with_hints: vec![],
|
||||
version: None,
|
||||
partitions: vec![],
|
||||
with_ordinality: false,
|
||||
},
|
||||
joins: vec![],
|
||||
}
|
||||
);
|
||||
|
|
@ -74,25 +78,30 @@ fn test_double_quotes_over_db_schema_table_name() {
|
|||
select.projection[0],
|
||||
SelectItem::UnnamedExpr(Expr::Identifier(Ident {
|
||||
value: "col1".to_string(),
|
||||
quote_style: Some('"'),
|
||||
span: Span::empty(),
|
||||
quote_style: Some('"')
|
||||
})),
|
||||
);
|
||||
assert_eq!(
|
||||
select.from[0],
|
||||
TableWithJoins {
|
||||
relation: table_from_name(ObjectName::from(vec![
|
||||
Ident {
|
||||
value: "test_schema".to_string(),
|
||||
quote_style: Some('"'),
|
||||
span: Span::empty(),
|
||||
},
|
||||
Ident {
|
||||
value: "test_table".to_string(),
|
||||
quote_style: Some('"'),
|
||||
span: Span::empty(),
|
||||
}
|
||||
])),
|
||||
relation: TableFactor::Table {
|
||||
name: ObjectName(vec![
|
||||
Ident {
|
||||
value: "test_schema".to_string(),
|
||||
quote_style: Some('"')
|
||||
},
|
||||
Ident {
|
||||
value: "test_table".to_string(),
|
||||
quote_style: Some('"')
|
||||
}
|
||||
]),
|
||||
alias: None,
|
||||
args: None,
|
||||
with_hints: vec![],
|
||||
version: None,
|
||||
partitions: vec![],
|
||||
with_ordinality: false,
|
||||
},
|
||||
joins: vec![],
|
||||
}
|
||||
);
|
||||
|
|
@ -112,12 +121,10 @@ fn parse_delimited_identifiers() {
|
|||
args,
|
||||
with_hints,
|
||||
version,
|
||||
..
|
||||
with_ordinality: _,
|
||||
partitions: _,
|
||||
} => {
|
||||
assert_eq!(
|
||||
ObjectName::from(vec![Ident::with_quote('"', "a table")]),
|
||||
name
|
||||
);
|
||||
assert_eq!(vec![Ident::with_quote('"', "a table")], name.0);
|
||||
assert_eq!(Ident::with_quote('"', "alias"), alias.unwrap().name);
|
||||
assert!(args.is_none());
|
||||
assert!(with_hints.is_empty());
|
||||
|
|
@ -136,8 +143,7 @@ fn parse_delimited_identifiers() {
|
|||
);
|
||||
assert_eq!(
|
||||
&Expr::Function(Function {
|
||||
name: ObjectName::from(vec![Ident::with_quote('"', "myfun")]),
|
||||
uses_odbc_syntax: false,
|
||||
name: ObjectName(vec![Ident::with_quote('"', "myfun")]),
|
||||
parameters: FunctionArguments::None,
|
||||
args: FunctionArguments::List(FunctionArgumentList {
|
||||
duplicate_treatment: None,
|
||||
|
|
@ -160,8 +166,6 @@ fn parse_delimited_identifiers() {
|
|||
}
|
||||
|
||||
redshift().verified_stmt(r#"CREATE TABLE "foo" ("bar" "int")"#);
|
||||
// An alias starting with a number
|
||||
redshift().verified_stmt(r#"CREATE TABLE "foo" ("1" INT)"#);
|
||||
redshift().verified_stmt(r#"ALTER TABLE foo ADD CONSTRAINT "bar" PRIMARY KEY (baz)"#);
|
||||
//TODO verified_stmt(r#"UPDATE foo SET "bar" = 5"#);
|
||||
}
|
||||
|
|
@ -192,218 +196,3 @@ fn test_create_view_with_no_schema_binding() {
|
|||
redshift_and_generic()
|
||||
.verified_stmt("CREATE VIEW myevent AS SELECT eventname FROM event WITH NO SCHEMA BINDING");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_redshift_json_path() {
|
||||
let dialects = all_dialects_where(|d| d.supports_partiql());
|
||||
let sql = "SELECT cust.c_orders[0].o_orderkey FROM customer_orders_lineitem";
|
||||
let select = dialects.verified_only_select(sql);
|
||||
|
||||
assert_eq!(
|
||||
&Expr::JsonAccess {
|
||||
value: Box::new(Expr::CompoundIdentifier(vec![
|
||||
Ident::new("cust"),
|
||||
Ident::new("c_orders")
|
||||
])),
|
||||
path: JsonPath {
|
||||
path: vec![
|
||||
JsonPathElem::Bracket {
|
||||
key: Expr::value(number("0"))
|
||||
},
|
||||
JsonPathElem::Dot {
|
||||
key: "o_orderkey".to_string(),
|
||||
quoted: false
|
||||
}
|
||||
]
|
||||
}
|
||||
},
|
||||
expr_from_projection(only(&select.projection))
|
||||
);
|
||||
|
||||
let sql = "SELECT cust.c_orders[0]['id'] FROM customer_orders_lineitem";
|
||||
let select = dialects.verified_only_select(sql);
|
||||
assert_eq!(
|
||||
&Expr::JsonAccess {
|
||||
value: Box::new(Expr::CompoundIdentifier(vec![
|
||||
Ident::new("cust"),
|
||||
Ident::new("c_orders")
|
||||
])),
|
||||
path: JsonPath {
|
||||
path: vec![
|
||||
JsonPathElem::Bracket {
|
||||
key: Expr::value(number("0"))
|
||||
},
|
||||
JsonPathElem::Bracket {
|
||||
key: Expr::Value(
|
||||
(Value::SingleQuotedString("id".to_owned())).with_empty_span()
|
||||
)
|
||||
}
|
||||
]
|
||||
}
|
||||
},
|
||||
expr_from_projection(only(&select.projection))
|
||||
);
|
||||
|
||||
let sql = "SELECT db1.sc1.tbl1.col1[0]['id'] FROM customer_orders_lineitem";
|
||||
let select = dialects.verified_only_select(sql);
|
||||
assert_eq!(
|
||||
&Expr::JsonAccess {
|
||||
value: Box::new(Expr::CompoundIdentifier(vec![
|
||||
Ident::new("db1"),
|
||||
Ident::new("sc1"),
|
||||
Ident::new("tbl1"),
|
||||
Ident::new("col1")
|
||||
])),
|
||||
path: JsonPath {
|
||||
path: vec![
|
||||
JsonPathElem::Bracket {
|
||||
key: Expr::value(number("0"))
|
||||
},
|
||||
JsonPathElem::Bracket {
|
||||
key: Expr::Value(
|
||||
(Value::SingleQuotedString("id".to_owned())).with_empty_span()
|
||||
)
|
||||
}
|
||||
]
|
||||
}
|
||||
},
|
||||
expr_from_projection(only(&select.projection))
|
||||
);
|
||||
|
||||
let sql = r#"SELECT db1.sc1.tbl1.col1[0]."id" FROM customer_orders_lineitem"#;
|
||||
let select = dialects.verified_only_select(sql);
|
||||
assert_eq!(
|
||||
&Expr::JsonAccess {
|
||||
value: Box::new(Expr::CompoundIdentifier(vec![
|
||||
Ident::new("db1"),
|
||||
Ident::new("sc1"),
|
||||
Ident::new("tbl1"),
|
||||
Ident::new("col1")
|
||||
])),
|
||||
path: JsonPath {
|
||||
path: vec![
|
||||
JsonPathElem::Bracket {
|
||||
key: Expr::value(number("0"))
|
||||
},
|
||||
JsonPathElem::Dot {
|
||||
key: "id".to_string(),
|
||||
quoted: true,
|
||||
}
|
||||
]
|
||||
}
|
||||
},
|
||||
expr_from_projection(only(&select.projection))
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_parse_json_path_from() {
|
||||
let dialects = all_dialects_where(|d| d.supports_partiql());
|
||||
let select = dialects.verified_only_select("SELECT * FROM src[0].a AS a");
|
||||
match &select.from[0].relation {
|
||||
TableFactor::Table {
|
||||
name, json_path, ..
|
||||
} => {
|
||||
assert_eq!(name, &ObjectName::from(vec![Ident::new("src")]));
|
||||
assert_eq!(
|
||||
json_path,
|
||||
&Some(JsonPath {
|
||||
path: vec![
|
||||
JsonPathElem::Bracket {
|
||||
key: Expr::value(number("0"))
|
||||
},
|
||||
JsonPathElem::Dot {
|
||||
key: "a".to_string(),
|
||||
quoted: false
|
||||
}
|
||||
]
|
||||
})
|
||||
);
|
||||
}
|
||||
_ => panic!(),
|
||||
}
|
||||
|
||||
let select = dialects.verified_only_select("SELECT * FROM src[0].a[1].b AS a");
|
||||
match &select.from[0].relation {
|
||||
TableFactor::Table {
|
||||
name, json_path, ..
|
||||
} => {
|
||||
assert_eq!(name, &ObjectName::from(vec![Ident::new("src")]));
|
||||
assert_eq!(
|
||||
json_path,
|
||||
&Some(JsonPath {
|
||||
path: vec![
|
||||
JsonPathElem::Bracket {
|
||||
key: Expr::value(number("0"))
|
||||
},
|
||||
JsonPathElem::Dot {
|
||||
key: "a".to_string(),
|
||||
quoted: false
|
||||
},
|
||||
JsonPathElem::Bracket {
|
||||
key: Expr::Value(
|
||||
(Value::Number("1".parse().unwrap(), false)).with_empty_span()
|
||||
)
|
||||
},
|
||||
JsonPathElem::Dot {
|
||||
key: "b".to_string(),
|
||||
quoted: false
|
||||
},
|
||||
]
|
||||
})
|
||||
);
|
||||
}
|
||||
_ => panic!(),
|
||||
}
|
||||
|
||||
let select = dialects.verified_only_select("SELECT * FROM src.a.b");
|
||||
match &select.from[0].relation {
|
||||
TableFactor::Table {
|
||||
name, json_path, ..
|
||||
} => {
|
||||
assert_eq!(
|
||||
name,
|
||||
&ObjectName::from(vec![Ident::new("src"), Ident::new("a"), Ident::new("b")])
|
||||
);
|
||||
assert_eq!(json_path, &None);
|
||||
}
|
||||
_ => panic!(),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_parse_select_numbered_columns() {
|
||||
// An alias starting with a number
|
||||
redshift_and_generic().verified_stmt(r#"SELECT 1 AS "1" FROM a"#);
|
||||
redshift_and_generic().verified_stmt(r#"SELECT 1 AS "1abc" FROM a"#);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_parse_nested_quoted_identifier() {
|
||||
redshift().verified_stmt(r#"SELECT 1 AS ["1"] FROM a"#);
|
||||
redshift().verified_stmt(r#"SELECT 1 AS ["[="] FROM a"#);
|
||||
redshift().verified_stmt(r#"SELECT 1 AS ["=]"] FROM a"#);
|
||||
redshift().verified_stmt(r#"SELECT 1 AS ["a[b]"] FROM a"#);
|
||||
// trim spaces
|
||||
redshift().one_statement_parses_to(r#"SELECT 1 AS [ " 1 " ]"#, r#"SELECT 1 AS [" 1 "]"#);
|
||||
// invalid query
|
||||
assert!(redshift()
|
||||
.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 🚀");
|
||||
}
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -214,6 +214,7 @@ fn parse_create_table_auto_increment() {
|
|||
vec![ColumnDef {
|
||||
name: "bar".into(),
|
||||
data_type: DataType::Int(None),
|
||||
collation: None,
|
||||
options: vec![
|
||||
ColumnOptionDef {
|
||||
name: None,
|
||||
|
|
@ -242,6 +243,7 @@ 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,
|
||||
|
|
@ -284,11 +286,13 @@ 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![],
|
||||
},
|
||||
],
|
||||
|
|
@ -324,7 +328,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!(
|
||||
|
|
@ -369,9 +373,7 @@ fn test_placeholder() {
|
|||
let ast = sqlite().verified_only_select(sql);
|
||||
assert_eq!(
|
||||
ast.projection[0],
|
||||
UnnamedExpr(Expr::Value(
|
||||
(Value::Placeholder("@xxx".into())).with_empty_span()
|
||||
)),
|
||||
UnnamedExpr(Expr::Value(Value::Placeholder("@xxx".into()))),
|
||||
);
|
||||
}
|
||||
|
||||
|
|
@ -410,14 +412,13 @@ fn parse_window_function_with_filter() {
|
|||
"count",
|
||||
"user_defined_function",
|
||||
] {
|
||||
let sql = format!("SELECT {func_name}(x) FILTER (WHERE y) OVER () FROM t");
|
||||
let sql = format!("SELECT {}(x) FILTER (WHERE y) OVER () FROM t", func_name);
|
||||
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::from(vec![Ident::new(func_name)]),
|
||||
uses_odbc_syntax: false,
|
||||
name: ObjectName(vec![Ident::new(func_name)]),
|
||||
parameters: FunctionArguments::None,
|
||||
args: FunctionArguments::List(FunctionArgumentList {
|
||||
duplicate_treatment: None,
|
||||
|
|
@ -444,15 +445,11 @@ 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(ValueWithSpan {
|
||||
value: Value::SingleQuotedString(literal_name),
|
||||
span: _,
|
||||
}),
|
||||
database_file_name: Expr::Value(Value::SingleQuotedString(literal_name)),
|
||||
database: true,
|
||||
} => {
|
||||
assert_eq!(schema_name.value, "test");
|
||||
|
|
@ -468,20 +465,27 @@ fn parse_update_tuple_row_values() {
|
|||
assert_eq!(
|
||||
sqlite().verified_stmt("UPDATE x SET (a, b) = (1, 2)"),
|
||||
Statement::Update {
|
||||
or: None,
|
||||
assignments: vec![Assignment {
|
||||
target: AssignmentTarget::Tuple(vec![
|
||||
ObjectName::from(vec![Ident::new("a"),]),
|
||||
ObjectName::from(vec![Ident::new("b"),]),
|
||||
ObjectName(vec![Ident::new("a"),]),
|
||||
ObjectName(vec![Ident::new("b"),]),
|
||||
]),
|
||||
value: Expr::Tuple(vec![
|
||||
Expr::Value((Value::Number("1".parse().unwrap(), false)).with_empty_span()),
|
||||
Expr::Value((Value::Number("2".parse().unwrap(), false)).with_empty_span())
|
||||
Expr::Value(Value::Number("1".parse().unwrap(), false)),
|
||||
Expr::Value(Value::Number("2".parse().unwrap(), false))
|
||||
])
|
||||
}],
|
||||
selection: None,
|
||||
table: TableWithJoins {
|
||||
relation: table_from_name(ObjectName::from(vec![Ident::new("x")])),
|
||||
relation: TableFactor::Table {
|
||||
name: ObjectName(vec![Ident::new("x")]),
|
||||
alias: None,
|
||||
args: None,
|
||||
with_hints: vec![],
|
||||
version: None,
|
||||
partitions: vec![],
|
||||
with_ordinality: false,
|
||||
},
|
||||
joins: vec![],
|
||||
},
|
||||
from: None,
|
||||
|
|
@ -521,9 +525,32 @@ fn parse_start_transaction_with_modifier() {
|
|||
sqlite_and_generic().verified_stmt("BEGIN DEFERRED TRANSACTION");
|
||||
sqlite_and_generic().verified_stmt("BEGIN IMMEDIATE TRANSACTION");
|
||||
sqlite_and_generic().verified_stmt("BEGIN EXCLUSIVE TRANSACTION");
|
||||
sqlite_and_generic().verified_stmt("BEGIN DEFERRED");
|
||||
sqlite_and_generic().verified_stmt("BEGIN IMMEDIATE");
|
||||
sqlite_and_generic().verified_stmt("BEGIN EXCLUSIVE");
|
||||
sqlite_and_generic().one_statement_parses_to("BEGIN DEFERRED", "BEGIN DEFERRED TRANSACTION");
|
||||
sqlite_and_generic().one_statement_parses_to("BEGIN IMMEDIATE", "BEGIN IMMEDIATE TRANSACTION");
|
||||
sqlite_and_generic().one_statement_parses_to("BEGIN EXCLUSIVE", "BEGIN EXCLUSIVE TRANSACTION");
|
||||
|
||||
let unsupported_dialects = TestedDialects::new(
|
||||
all_dialects()
|
||||
.dialects
|
||||
.into_iter()
|
||||
.filter(|x| !(x.is::<SQLiteDialect>() || x.is::<GenericDialect>()))
|
||||
.collect(),
|
||||
);
|
||||
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]
|
||||
|
|
@ -536,60 +563,10 @@ 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())).with_empty_span()
|
||||
))
|
||||
);
|
||||
assert_eq!(right, Box::new(Expr::Value(Placeholder("$id".to_string()))));
|
||||
}
|
||||
_ => unreachable!(),
|
||||
}
|
||||
|
||||
// $$ is a valid placeholder in SQLite
|
||||
match sqlite().verified_expr("id = $$") {
|
||||
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())).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 {
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue