pax_global_header00006660000000000000000000000064151752403700014516gustar00rootroot0000000000000052 comment=3dd0e30d8bb1d2a6775f62d2b84839b60133effb apache-datafusion-sqlparser-rs-0.62.0/000077500000000000000000000000001517524037000176135ustar00rootroot00000000000000apache-datafusion-sqlparser-rs-0.62.0/.asf.yaml000066400000000000000000000033521517524037000213310ustar00rootroot00000000000000# 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. # This file controls the settings of this repository # # See more details at # https://cwiki.apache.org/confluence/display/INFRA/Git+-+.asf.yaml+features notifications: commits: commits@datafusion.apache.org issues: github@datafusion.apache.org pullrequests: github@datafusion.apache.org github: description: "Extensible SQL Lexer and Parser for Rust" labels: - big-data - rust - sql enabled_merge_buttons: squash: true merge: false rebase: false features: issues: true protected_branches: main: required_status_checks: contexts: - "codestyle" - "lint" - "benchmark-lint" - "compile" - "docs" - "compile-no-std" - "test (stable)" - "test (beta)" - "test (nightly)" - "Release Audit Tool (RAT)" pull_requests: # enable updating head branches of pull requests allow_update_branch: true allow_auto_merge: true apache-datafusion-sqlparser-rs-0.62.0/.github/000077500000000000000000000000001517524037000211535ustar00rootroot00000000000000apache-datafusion-sqlparser-rs-0.62.0/.github/actions/000077500000000000000000000000001517524037000226135ustar00rootroot00000000000000apache-datafusion-sqlparser-rs-0.62.0/.github/actions/setup-builder/000077500000000000000000000000001517524037000253775ustar00rootroot00000000000000apache-datafusion-sqlparser-rs-0.62.0/.github/actions/setup-builder/action.yaml000066400000000000000000000030101517524037000275320ustar00rootroot00000000000000# 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: Prepare Rust Builder description: 'Prepare Rust Build Environment' inputs: rust-version: description: 'version of rust to install (e.g. stable)' required: true default: 'stable' targets: description: 'The toolchain targets to add, comma-separated' default: '' runs: using: "composite" steps: - name: Setup Rust Toolchain shell: bash run: | echo "Installing ${{ inputs.rust-version }}" if [ -n "${{ inputs.targets}}" ]; then rustup toolchain install ${{ inputs.rust-version }} -t ${{ inputs.targets }} else rustup toolchain install ${{ inputs.rust-version }} fi rustup default ${{ inputs.rust-version }} rustup component add rustfmt clippy apache-datafusion-sqlparser-rs-0.62.0/.github/dependabot.yml000066400000000000000000000020371517524037000240050ustar00rootroot00000000000000# 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. version: 2 updates: - package-ecosystem: cargo directory: "/" schedule: interval: daily open-pull-requests-limit: 10 - package-ecosystem: cargo directory: "/sqlparser_bench" schedule: interval: daily open-pull-requests-limit: 10 apache-datafusion-sqlparser-rs-0.62.0/.github/workflows/000077500000000000000000000000001517524037000232105ustar00rootroot00000000000000apache-datafusion-sqlparser-rs-0.62.0/.github/workflows/license.yml000066400000000000000000000022751517524037000253630ustar00rootroot00000000000000# 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: merge_group: 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 . apache-datafusion-sqlparser-rs-0.62.0/.github/workflows/rust.yml000066400000000000000000000061221517524037000247310ustar00rootroot00000000000000# 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: Rust on: push: # When PR is in the Merge Queue, GitHub will create a temporary branch - but we already have a # CI running because of `merge_group` # See also: https://github.com/orgs/community/discussions/15254 branches-ignore: - 'gh-readonly-queue/**' pull_request: merge_group: permissions: contents: read jobs: codestyle: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - name: Setup Rust Toolchain uses: ./.github/actions/setup-builder - run: cargo fmt --all -- --check lint: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - name: Setup Rust Toolchain 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: - uses: actions/checkout@v4 - name: Setup Rust Toolchain uses: ./.github/actions/setup-builder - run: cargo check --all-targets --all-features docs: runs-on: ubuntu-latest env: RUSTDOCFLAGS: "-Dwarnings" steps: - uses: actions/checkout@v4 - name: Setup Rust Toolchain uses: ./.github/actions/setup-builder - run: cargo doc --document-private-items --no-deps --workspace --all-features compile-no-std: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - name: Setup Rust Toolchain uses: ./.github/actions/setup-builder with: targets: 'thumbv6m-none-eabi' - run: cargo check --no-default-features --target thumbv6m-none-eabi test: strategy: matrix: rust: [stable, beta, nightly] runs-on: ubuntu-latest steps: - name: Checkout uses: actions/checkout@v4 - name: Setup Rust Toolchain 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 - name: Test run: cargo test --all-features apache-datafusion-sqlparser-rs-0.62.0/.github/workflows/stale.yml000066400000000000000000000027201517524037000250440ustar00rootroot00000000000000# 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: "Close stale PRs" on: schedule: - cron: "30 1 * * *" jobs: close-stale-prs: runs-on: ubuntu-latest permissions: issues: write pull-requests: write steps: - uses: actions/stale@v9 with: stale-pr-message: "Thank you for your contribution. Unfortunately, this pull request is stale because it has been open 60 days with no activity. Please remove the stale label or comment or this will be closed in 7 days." days-before-pr-stale: 60 days-before-pr-close: 7 # do not close stale issues days-before-issue-stale: -1 days-before-issue-close: -1 repo-token: ${{ secrets.GITHUB_TOKEN }} apache-datafusion-sqlparser-rs-0.62.0/.gitignore000066400000000000000000000006141517524037000216040ustar00rootroot00000000000000# Generated by Cargo # will have compiled files and executables /target/ /sqlparser_bench/target/ /derive/target/ dev/dist # Remove Cargo.lock from gitignore if creating an executable, leave it for libraries # More information here http://doc.crates.io/guide.html#cargotoml-vs-cargolock Cargo.lock # These are backup files generated by rustfmt **/*.rs.bk # IDEs .idea .vscode *.swp .DS_storeapache-datafusion-sqlparser-rs-0.62.0/.tool-versions000066400000000000000000000000131517524037000224310ustar00rootroot00000000000000rust 1.75.0apache-datafusion-sqlparser-rs-0.62.0/AGENTS.md000066400000000000000000000053751517524037000211300ustar00rootroot00000000000000# Extensible SQL Lexer and Parser for Rust Agents Guidelines ## General Agent Workflow 1. You will write unit tests to ensure your code change is working as expected. 2. You will run the commands in the Pre Commit Checks section below to ensure your change is ready for a pull request. 3. When instructed to open a PR, you will follow the instructions in the Pull Request Guidelines section below. ## General Coding Guidelines 1. Refrain from adding conditions on specific dialects, such as `dialect_is!(...)` or `dialect_of!(... | ...)`. Instead, define a new function in the `Dialect` trait that describes the condition, so that dialects can turn this condition on more easily. 2. Make targeted code changes and refrain from refactoring, unless it's absolutely required. ## Unit Tests Guidelines - New unit tests should be added to the `tests` module in the corresponding dialect file (e.g., `tests/sqlparser_redshift.rs` for Redshift), and should be placed at the end of the file. - If the new functionality is gated using a dialect function, and the SQL is likely relevant in most dialects, tests should be placed under `tests/sqlparser_common.rs`. - When testing a multi-line SQL statement, use a raw string literal, i.e. `r#"..."#` to preserve formatting. - The parser builds an abstract syntax tree (AST) from the SQL statement and has functionality to display the tree as SQL. Use the following template for simple unit tests where you expect the SQL created from the AST to be the same as the input SQL: ```rust ().verified_stmt(r#"..."#); ``` For example: `snowflake().verified_stmt(r#"SELECT * FROM my_table"#)`. Use `one_statement_parses_to` instead of `verified_stmt` when you expect the SQL created by the AST to differ than the input SQL. For example: ```rust snowflake().one_statement_parses_to( "SELECT * FROM my_table t", "SELECT * FROM my_table AS t", ) ``` ## Analyzing Parsing Issues You can try to simplify the SQL statement to identify the root cause of the parsing issue. This may involve removing certain clauses or components of the SQL statement to see if it can be parsed successfully. Additionally, you can compare the problematic SQL statement with similar statements that are parsed correctly to identify any differences that may be causing the issue. ## Pre Commit Checks Run the following commands before you commit to ensure the change will pass the CI process: ```bash cargo test --all-features cargo fmt --all cargo clippy --all-targets --all-features -- -D warnings ``` ## Pull Request Guidelines 1. PR title should follow this format: `: `, For example, `Showflake: Add support for casting to VARIANT`. 2. Make the PR comment short, provide an example of what was not working and a short description of the fix. Be succint. apache-datafusion-sqlparser-rs-0.62.0/CHANGELOG.md000066400000000000000000000024431517524037000214270ustar00rootroot00000000000000 # Changelog All notable changes to this project will be documented in one of the linked files. 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. - Past releases: See https://github.com/apache/datafusion-sqlparser-rs/tree/main/changelog apache-datafusion-sqlparser-rs-0.62.0/Cargo.toml000066400000000000000000000045661517524037000215560ustar00rootroot00000000000000# 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. [package] name = "sqlparser" description = "Extensible SQL Lexer and Parser with support for ANSI SQL:2011" version = "0.62.0" authors = ["Apache DataFusion "] homepage = "https://github.com/apache/datafusion-sqlparser-rs" documentation = "https://docs.rs/sqlparser/" keywords = ["ansi", "sql", "lexer", "parser"] repository = "https://github.com/apache/datafusion-sqlparser-rs" license = "Apache-2.0" include = [ "src/**/*.rs", "Cargo.toml", "LICENSE.TXT", ] edition = "2021" [lib] name = "sqlparser" path = "src/lib.rs" [features] default = ["std", "recursive-protection"] std = [] recursive-protection = ["std", "recursive"] # Enable JSON output in the `cli` example: json_example = ["serde_json", "serde"] derive-dialect = ["sqlparser_derive"] 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_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.5.0", path = "derive", optional = true } [dev-dependencies] simple_logger = "5.0" matches = "0.1" pretty_assertions = "1" [[test]] name = "sqlparser_derive_dialect" required-features = ["derive-dialect"] [package.metadata.docs.rs] # Document these features on docs.rs features = ["serde", "visitor", "derive-dialect"] apache-datafusion-sqlparser-rs-0.62.0/HEADER000066400000000000000000000014401517524037000204650ustar00rootroot00000000000000// 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.apache-datafusion-sqlparser-rs-0.62.0/LICENSE.TXT000066400000000000000000000251371517524037000213060ustar00rootroot00000000000000 Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright [yyyy] [name of copyright owner] Licensed 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. apache-datafusion-sqlparser-rs-0.62.0/README.md000066400000000000000000000306031517524037000210740ustar00rootroot00000000000000 # Extensible SQL Lexer and Parser for Rust [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0) [![Version](https://img.shields.io/crates/v/sqlparser.svg)](https://crates.io/crates/sqlparser) [![Build Status](https://github.com/apache/datafusion-sqlparser-rs/actions/workflows/rust.yml/badge.svg)](https://github.com/sqlparser-rs/sqlparser-rs/actions?query=workflow%3ARust+branch%3Amain) [![Coverage Status](https://coveralls.io/repos/github/sqlparser-rs/sqlparser-rs/badge.svg?branch=main)](https://coveralls.io/github/sqlparser-rs/sqlparser-rs?branch=main) [![Gitter Chat](https://badges.gitter.im/sqlparser-rs/community.svg)](https://gitter.im/sqlparser-rs/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) This crate contains a lexer and parser for SQL that conforms with the [ANSI/ISO SQL standard][sql-standard] and other dialects. This crate is used as a foundation for SQL query engines, vendor-specific parsers, and various SQL analysis. ## Example To parse a simple `SELECT` statement: ```rust use sqlparser::dialect::GenericDialect; use sqlparser::parser::Parser; let sql = "SELECT a, b, 123, myfunc(b) \ FROM table_1 \ WHERE a > b AND b < 100 \ ORDER BY a DESC, b"; let dialect = GenericDialect {}; // or AnsiDialect, or your own dialect ... let ast = Parser::parse_sql(&dialect, sql).unwrap(); 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 })] ``` ## Features The following optional [crate features](https://doc.rust-lang.org/cargo/reference/features.html) are available: * `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 This crate provides only a syntax parser, and tries to avoid applying any SQL semantics, and accepts queries that specific databases would reject, even when using that Database's specific `Dialect`. For example, `CREATE TABLE(x int, x int)` is accepted by this crate, even though most SQL engines will reject this statement due to the repeated column name `x`. This crate avoids semantic analysis because it varies drastically between dialects and implementations. If you want to do semantic analysis, feel free to use this project as a base. ## Preserves Syntax Round Trip This crate allows users to recover the original SQL text (with comments removed, normalized whitespace and keyword capitalization), which is useful for tools that analyze and manipulate SQL. This means that other than comments, whitespace and the capitalization of 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 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. Unfortunately, stating anything more specific about compliance is difficult. There is no publicly available test suite that can assess compliance automatically, and doing so manually would strain the project's limited resources. Still, we are interested in eventually supporting the full SQL dialect, and we are slowly building out our own test suite. If you are assessing whether this project will be suitable for your needs, you'll likely need to experimentally verify whether it supports the subset of SQL that you need. Please file issues about any unsupported queries that you discover. Doing so helps us prioritize support for the portions of the standard that are actually used. Note that if you urgently need support for a feature, you will likely need to write the implementation yourself. See the [Contributing](#Contributing) section for details. ## Command line This crate contains a CLI program that can parse a file and dump the results as JSON: ``` $ 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], [Readyset] and [GreptimeDB]. If your project is using sqlparser-rs feel free to make a PR to add it to this list. ## Design The core expression parser uses the [Pratt Parser] design, which is a top-down operator-precedence (TDOP) parser, while the surrounding SQL statement parser is a traditional, hand-written recursive descent parser. Eli Bendersky has a good [tutorial on TDOP parsers][tdop-tutorial], if you are interested in learning more about the technique. We are a fan of this design pattern over parser generators for the following reasons: - Code is simple to write and can be concise and elegant - Performance is generally better than code generated by parser generators - Debugging is much easier with hand-written code - It is far easier to extend and make dialect-specific extensions compared to using a parser generator ### Supporting custom SQL dialects This is a work in progress, but we have some notes on [writing a custom SQL parser](docs/custom_sql_parser.md). ## Contributing Contributions are highly encouraged! However, the bandwidth we have to maintain this crate is limited. Please read the following sections carefully. ### New Syntax The most commonly accepted PRs add support for or fix a bug in a feature in the SQL standard, or a popular RDBMS, such as Microsoft SQL Server or PostgreSQL, will likely be accepted after a brief review. Any SQL feature that is dialect specific should be parsed by *both* the relevant [`Dialect`] as well as [`GenericDialect`]. ### Major API Changes The current maintainers do not plan for any substantial changes to this crate's API. PRs proposing major refactors are not likely to be accepted. ### Testing While we hope to review PRs in a reasonably timely fashion, it may take a week or more. In order to speed the process, please make sure the PR passes all CI checks, and includes tests demonstrating your code works as intended (and to avoid regressions). Remember to also test error paths. PRs without tests will not be reviewed or merged. Since the CI ensures that `cargo test`, `cargo fmt`, and `cargo clippy`, pass you should likely to run all three commands locally before submitting your PR. ### Filing Issues If you are unable to submit a patch, feel free to file an issue instead. Please try to include: * some representative examples of the syntax you wish to support or fix; * the relevant bits of the [SQL grammar][sql-2016-grammar], if the syntax is part of SQL:2016; and * links to documentation for the feature for a few of the most popular databases that support it. Unfortunately, if you need support for a feature, you will likely need to implement it yourself, or file a well enough described ticket that another member of the community can do so. 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 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 All code in this repository is licensed under the [Apache Software License 2.0](LICENSE.txt). Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be licensed as above, without any additional terms or conditions. [tdop-tutorial]: https://eli.thegreenplace.net/2010/01/02/top-down-operator-precedence-parsing [`cargo fmt`]: https://github.com/rust-lang/rustfmt#on-the-stable-toolchain [current issues]: https://github.com/sqlparser-rs/sqlparser-rs/issues [DataFusion]: https://github.com/apache/arrow-datafusion [LocustDB]: https://github.com/cswinter/LocustDB [Ballista]: https://github.com/apache/arrow-ballista [GlueSQL]: https://github.com/gluesql/gluesql [Opteryx]: https://github.com/mabel-dev/opteryx [Polars]: https://pola.rs/ [PRQL]: https://github.com/PRQL/prql [Qrlew]: https://github.com/Qrlew/qrlew [JumpWire]: https://github.com/extragoodlabs/jumpwire [ParadeDB]: https://github.com/paradedb/paradedb [Pratt Parser]: https://tdop.github.io/ [sql-2016-grammar]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html [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 [Readyset]: https://github.com/readysettech/readyset apache-datafusion-sqlparser-rs-0.62.0/SECURITY.md000066400000000000000000000016051517524037000214060ustar00rootroot00000000000000 # Security Policy ## Reporting a Vulnerability Please report security issues to `andrew@nerdnetworks.org`apache-datafusion-sqlparser-rs-0.62.0/changelog/000077500000000000000000000000001517524037000215425ustar00rootroot00000000000000apache-datafusion-sqlparser-rs-0.62.0/changelog/0.51.0-pre.md000066400000000000000000001663461517524037000234110ustar00rootroot00000000000000 ## [0.51.0] 2024-09-11 As always, huge props to @iffyio @jmhain and @lovasoa for their help reviewing and merging PRs 🙏. Without them this project would not be possible. Reminder: we are in the final phases of moving sqlparser-rs into the Apache DataFusion project: https://github.com/sqlparser-rs/sqlparser-rs/issues/1294 ### Fixed * Fix Hive table comment should be after table column definitions (#1413) - Thanks @git-hulk * Fix stack overflow in `parse_subexpr` (#1410) - Thanks @eejbyfeldt * Fix `INTERVAL` parsing to support expressions and units via dialect (#1398) - Thanks @samuelcolvin * Fix identifiers starting with `$` should be regarded as a placeholder in SQLite (#1402) - Thanks @git-hulk ### Added * Support for MSSQL table options (#1414) - Thanks @bombsimon * Test showing how negative constants are parsed (#1421) - Thanks @alamb * Support databricks dialect to dialect_from_str (#1416) - Thanks @milenkovicmalamb * Support `DROP|CLEAR|MATERIALIZE PROJECTION` syntax for ClickHouse (#1417) - Thanks @git-hulk * Support postgres `TRUNCATE` syntax (#1406) - Thanks @tobyhede * Support `CREATE INDEX` with clause (#1389) - Thanks @lewiszlw * Support parsing `CLUSTERED BY` clause for Hive (#1397) - Thanks @git-hulk * Support different `USE` statement syntaxes (#1387) - Thanks @kacpermuda * Support `ADD PROJECTION` syntax for ClickHouse (#1390) - Thanks @git-hulk ### Changed * Implement common traits for OneOrManyWithParens (#1368) - Thanks @gstvg * Cleanup parse_statement (#1407) - Thanks @samuelcolvin * Allow `DateTimeField::Custom` with `EXTRACT` in Postgres (#1394) - Thanks @samuelcolvin ## [0.50.0] 2024-08-15 Again, huge props to @iffyio @jmhain and @lovasoa for their help reviewing and merging PRs 🙏. Without them this project would not be possible. Reminder: are in the process of moving sqlparser to governed as part of the Apache DataFusion project: https://github.com/sqlparser-rs/sqlparser-rs/issues/1294 ### Fixed * Clippy 1.80 warnings (#1357) - Thanks @lovasoa ### Added * Support `STRUCT` and list of structs for DuckDB dialect (#1372) - Thanks @jayzhan211 * Support custom lexical precedence in PostgreSQL dialect (#1379) - Thanks @samuelcolvin * Support `FREEZE|UNFREEZE PARTITION` syntax for ClickHouse (#1380) - Thanks @git-hulk * Support scale in `CEIL` and `FLOOR` functions (#1377) - Thanks @seve-martinez * Support `CREATE TRIGGER` and `DROP TRIGGER` statements (#1352) - Thanks @LucaCappelletti94 * Support `EXTRACT` syntax for snowflake (#1374) - Thanks @seve-martinez * Support `ATTACH` / `DETACH PARTITION` for ClickHouse (#1362) - Thanks @git-hulk * Support Dialect level precedence, update Postgres Dialect to match Postgres (#1360) - Thanks @samuelcolvin * Support parsing empty map literal syntax for DuckDB and Generic dialects (#1361) - Thanks @goldmedal * Support `SETTINGS` clause for ClickHouse table-valued functions (#1358) - Thanks @Jesse-Bakker * Support `OPTIMIZE TABLE` statement for ClickHouse (#1359) - Thanks @git-hulk * Support `ON CLUSTER` in `ALTER TABLE` for ClickHouse (#1342) - Thanks @git-hulk * Support `GLOBAL` keyword before the join operator (#1353) - Thanks @git-hulk * Support postgres String Constants with Unicode Escapes (#1355) - Thanks @lovasoa * Support position with normal function call syntax for Snowflake (#1341) - Thanks @jmhain * Support `TABLE` keyword in `DESC|DESCRIBE|EXPLAIN TABLE` statement (#1351) - Thanks @git-hulk ### Changed * Only require `DESCRIBE TABLE` for Snowflake and ClickHouse dialect (#1386) - Thanks @ alamb * Rename (unreleased) `get_next_precedence_full` to `get_next_precedence_default` (#1378) - Thanks @samuelcolvin * Use local GitHub Action to replace setup-rust-action (#1371) - Thanks @git-hulk * Simplify arrow_cast tests (#1367) - Thanks @alamb * Update version of GitHub Actions (#1363) - Thanks @git-hulk * Make `Parser::maybe_parse` pub (#1364) - Thanks @Jesse-Bakker * Improve comments on 1Dialect` (#1366) - Thanks @alamb ## [0.49.0] 2024-07-23 As always, huge props to @iffyio @jmhain and @lovasoa for their help reviewing and merging PRs! We are in the process of moving sqlparser to governed as part of the Apache DataFusion project: https://github.com/sqlparser-rs/sqlparser-rs/issues/1294 ### Fixed * Fix quoted identifier regression edge-case with "from" in SELECT (#1346) - Thanks @alexander-beedie * Fix `AS` query clause should be after the create table options (#1339) - Thanks @git-hulk ### Added * Support `MATERIALIZED`/`ALIAS`/`EPHERMERAL` default column options for ClickHouse (#1348) - Thanks @git-hulk * Support `()` as the `GROUP BY` nothing (#1347) - Thanks @git-hulk * Support Map literal syntax for DuckDB and Generic (#1344) - Thanks @goldmedal * Support subquery expression in `SET` expressions (#1343) - Thanks @iffyio * Support `WITH FILL` for ClickHouse (#1330) - Thanks @nickpresta * Support `PARTITION BY` for PostgreSQL in `CREATE TABLE` statement (#1338) - Thanks @git-hulk * Support of table function `WITH ORDINALITY` modifier for Postgres (#1337) - Thanks @git-hulk ## [0.48.0] 2024-07-09 Huge shout out to @iffyio @jmhain and @lovasoa for their help reviewing and merging PRs! ### Fixed * Fix CI error message in CI (#1333) - Thanks @alamb * Fix typo in sqlparser-derive README (#1310) - Thanks @leoyvens * Re-enable trailing commas in DCL (#1318) - Thanks @MohamedAbdeen21 * Fix a few typos in comment lines (#1316) - Thanks @git-hulk * Fix Snowflake `SELECT * wildcard REPLACE ... RENAME` order (#1321) - Thanks @alexander-beedie * Allow semi-colon at the end of UNCACHE statement (#1320) - Thanks @LorrensP-2158466 * Return errors, not panic, when integers fail to parse in `AUTO_INCREMENT` and `TOP` (#1305) - Thanks @eejbyfeldt ### Added * Support `OWNER TO` clause in Postgres (#1314) - Thanks @gainings * Support `FORMAT` clause for ClickHouse (#1335) - Thanks @git-hulk * Support `DROP PROCEDURE` statement (#1324) - Thanks @LorrensP-2158466 * Support `PREWHERE` condition for ClickHouse dialect (#1328) - Thanks @git-hulk * Support `SETTINGS` pairs for ClickHouse dialect (#1327) - Thanks @git-hulk * Support `GROUP BY WITH MODIFIER` for ClickHouse dialect (#1323) - Thanks @git-hulk * Support DuckDB Union datatype (#1322) - Thanks @gstvg * Support parametric arguments to `FUNCTION` for ClickHouse dialect (#1315) - Thanks @git-hulk * Support `TO` in `CREATE VIEW` clause for Clickhouse (#1313) - Thanks @Bidaya0 * Support `UPDATE` statements that contain tuple assignments (#1317) - Thanks @lovasoa * Support `BY NAME quantifier across all set ops (#1309) - Thanks @alexander-beedie * Support SnowFlake exclusive `CREATE TABLE` options (#1233) - Thanks @balliegojr * Support ClickHouse `CREATE TABLE` with primary key and parametrised table engine (#1289) - Thanks @7phs * Support custom operators in Postgres (#1302) - Thanks @lovasoa * Support ClickHouse data types (#1285) - Thanks @7phs ### Changed * Add stale PR github workflow (#1331) - Thanks @alamb * Refine docs (#1326) - Thanks @emilsivervik * Improve error messages with additional colons (#1319) - Thanks @LorrensP-2158466 * Move Display fmt to struct for `CreateIndex` (#1307) - Thanks @philipcristiano * Enhancing Trailing Comma Option (#1212) - Thanks @MohamedAbdeen21 * Encapsulate `CreateTable`, `CreateIndex` into specific structs (#1291) - Thanks @philipcristiano ## [0.47.0] 2024-06-01 ### Fixed * Re-support Postgres array slice syntax (#1290) - Thanks @jmhain * Fix DoubleColon cast skipping AT TIME ZONE #1266 (#1267) - Thanks @dmitrybugakov * Fix for values as table name in Databricks and generic (#1278) - Thanks @jmhain ### Added * Support `ASOF` joins in Snowflake (#1288) - Thanks @jmhain * Support `CREATE VIEW` with fields and data types ClickHouse (#1292) - Thanks @7phs * Support view comments for Snowflake (#1287) - Thanks @bombsimon * Support dynamic pivot in Snowflake (#1280) - Thanks @jmhain * Support `CREATE FUNCTION` for BigQuery, generalize AST (#1253) - Thanks @iffyio * Support expression in `AT TIME ZONE` and fix precedence (#1272) - Thanks @jmhain * Support `IGNORE/RESPECT NULLS` inside function argument list for Databricks (#1263) - Thanks @jmhain * Support `SELECT * EXCEPT` Databricks (#1261) - Thanks @jmhain * Support triple quoted strings (#1262) - Thanks @iffyio * Support array indexing for duckdb (#1265) - Thanks @JichaoS * Support multiple SET variables (#1252) - Thanks @iffyio * Support `ANY_VALUE` `HAVING` clause (#1258) in BigQuery - Thanks @jmhain * Support keywords as field names in BigQuery struct syntax (#1254) - Thanks @iffyio * Support `GROUP_CONCAT()` in MySQL (#1256) - Thanks @jmhain * Support lambda functions in Databricks (#1257) - Thanks @jmhain * Add const generic peek_tokens method to parser (#1255) - Thanks @jmhain ## [0.46.0] 2024-05-03 ### Changed * Consolidate representation of function calls, remove `AggregateExpressionWithFilter`, `ArraySubquery`, `ListAgg` and `ArrayAgg` (#1247) - Thanks jmhain * Extended dialect trait to support numeric prefixed identifiers (#1188) - Thanks @groobyming * Update simple_logger requirement from 4.0 to 5.0 (#1246) - Thanks @dependabot * Improve parsing of JSON accesses on Postgres and Snowflake (#1215) - Thanks @jmhain * Encapsulate Insert and Delete into specific structs (#1224) - Thanks @tisonkun * Preserve double colon casts (and simplify cast representations) (#1221) - Thanks @jmhain ### Fixed * Fix redundant brackets in Hive/Snowflake/Redshift (#1229) - Thanks @yuval-illumex ### Added * Support values without parens in Snowflake and DataBricks (#1249) - Thanks @HiranmayaGundu * Support WINDOW clause after QUALIFY when parsing (#1248) - Thanks @iffyio * Support `DECLARE` parsing for mssql (#1235) - Thanks @devanbenz * Support `?`-based jsonb operators in Postgres (#1242) - THanks @ReppCodes * Support Struct datatype parsing for GenericDialect (#1241) - Thanks @duongcongtoai * Support BigQuery window function null treatment (#1239) - Thanks @iffyio * Support extend pivot operator - Thanks @iffyio * Support Databricks SQL dialect (#1220) - Thanks @jmhain * Support for MSSQL CONVERT styles (#1219) - Thanks @iffyio * Support window clause using named window in BigQuery (#1237) - Thanks @iffyio * Support for CONNECT BY (#1138) - Thanks @jmhain * Support object constants in Snowflake (#1223) - Thanks @jmhain * Support BigQuery MERGE syntax (#1217) - Thanks @iffyio * Support for MAX for NVARCHAR (#1232) - Thanks @ bombsimon * Support fixed size list types (#1231) - @@universalmind303 * Support Snowflake MATCH_RECOGNIZE syntax (#1222) - Thanks @jmhain * Support quoted string backslash escaping (#1177) - Thanks @iffyio * Support Modify Column for MySQL dialect (#1216) - Thanks @KKould * Support `select * ilike` for snowflake (#1228) - Thanks @HiranmayaGundu * Support wildcard replace in duckdb and snowflake syntax (#1226) - Thanks @HiranmayaGundu ## [0.45.0] 2024-04-12 ### Added * Support `DateTimeField` variants: `CUSTOM` and `WEEK(MONDAY)` (#1191) - Thanks @iffyio * Support for arbitrary expr in `MapAccessSyntax` (#1179) - Thanks @iffyio * Support unquoted hyphen in table/view declaration for BigQuery (#1178) - Thanks @iffyio * Support `CREATE/DROP SECRET` for duckdb dialect (#1208) - Thanks @JichaoS * Support MySQL `UNIQUE` table constraint (#1164) - Thanks @Nikita-str * Support tailing commas on Snowflake. (#1205) - Thanks @yassun7010 * Support `[FIRST | AFTER column_name]` in `ALTER TABLE` for MySQL (#1180) - Thanks @xring * Support inline comment with hash syntax for BigQuery (#1192) - Thanks @iffyio * Support named windows in OVER (window_definition) clause (#1166) - Thanks @Nikita-str * Support PARALLEL ... and for ..ON NULL INPUT ... to CREATE FUNCTION` (#1202) - Thanks @dimfeld * Support DuckDB functions named arguments with assignment operator (#1195) - Thanks @alamb * Support DuckDB struct literal syntax (#1194) - Thanks @gstvg * Support `$$` in generic dialect ... (#1185)- Thanks @milenkovicm * Support row_alias and col_aliases in `INSERT` statement for MySQL and Generic dialects (#1136) - Thanks @emin100 ### Fixed * Fix dollar quoted string tokenizer (#1193) - Thanks @ZacJW * Do not allocate in `impl Display` for `DateTimeField` (#1209) - Thanks @alamb * Fix parse `COPY INTO` stage names without parens for SnowFlake (#1187) - Thanks @mobuchowski * Solve stack overflow on RecursionLimitExceeded on debug builds (#1171) - Thanks @Nikita-str * Fix parsing of equality binary operator in function argument (#1182) - Thanks @jmhain * Fix some comments (#1184) - Thanks @sunxunle ### Changed * Cleanup `CREATE FUNCTION` tests (#1203) - Thanks @alamb * Parse `SUBSTRING FROM` syntax in all dialects, reflect change in the AST (#1173) - Thanks @lovasoa * Add identifier quote style to Dialect trait (#1170) - Thanks @backkem ## [0.44.0] 2024-03-02 ### Added * Support EXPLAIN / DESCR / DESCRIBE [FORMATTED | EXTENDED] (#1156) - Thanks @jonathanlehtoalamb * Support ALTER TABLE ... SET LOCATION (#1154) - Thanks @jonathanlehto * Support `ROW FORMAT DELIMITED` in Hive (#1155) - Thanks @jonathanlehto * Support `SERDEPROPERTIES` for `CREATE TABLE` with Hive (#1152) - Thanks @jonathanlehto * Support `EXECUTE ... USING` for Postgres (#1153) - Thanks @jonathanlehto * Support Postgres style `CREATE FUNCTION` in GenericDialect (#1159) - Thanks @alamb * Support `SET TBLPROPERTIES` (#1151) - Thanks @jonathanlehto * Support `UNLOAD` statement (#1150) - Thanks @jonathanlehto * Support `MATERIALIZED CTEs` (#1148) - Thanks @ReppCodes * Support `DECLARE` syntax for snowflake and bigquery (#1122) - Thanks @iffyio * Support `SELECT AS VALUE` and `SELECT AS STRUCT` for BigQuery (#1135) - Thanks @lustefaniak * Support `(+)` outer join syntax (#1145) - Thanks @jmhain * Support `INSERT INTO ... SELECT ... RETURNING`(#1132) - Thanks @lovasoa * Support DuckDB `INSTALL` and `LOAD` (#1127) - Thanks @universalmind303 * Support `=` operator in function args (#1128) - Thanks @universalmind303 * Support `CREATE VIEW IF NOT EXISTS` (#1118) - Thanks @7phs * Support `UPDATE FROM` for SQLite (further to #694) (#1117) - Thanks @ggaughan * Support optional `DELETE FROM` statement (#1120) - Thanks @iffyio * Support MySQL `SHOW STATUS` statement (#1119) - Thanks invm ### Fixed * Clean up nightly clippy lints (#1158) - Thanks @alamb * Handle escape, unicode, and hex in tokenize_escaped_single_quoted_string (#1146) - Thanks @JasonLi-cn * Fix panic while parsing `REPLACE` (#1140) - THanks @jjbayer * Fix clippy warning from rust 1.76 (#1130) - Thanks @alamb * Fix release instructions (#1115) - Thanks @alamb ### Changed * Add `parse_keyword_with_tokens` for paring keyword and tokens combination (#1141) - Thanks @viirya * Add ParadeDB to list of known users (#1142) - Thanks @philippemnoel * Accept JSON_TABLE both as an unquoted table name and a table-valued function (#1134) - Thanks @lovasoa ## [0.43.1] 2024-01-22 ### Changes * Fixed CHANGELOG ## [0.43.0] 2024-01-22 * NO CHANGES ## [0.42.0] 2024-01-22 ### Added * Support for constraint `CHARACTERISTICS` clause (#1099) - Thanks @dimfeld * Support for unquoted hyphenated identifiers on bigquery (#1109) - Thanks @jmhain * Support `BigQuery` table and view options (#1061) - Thanks @iffyio * Support Postgres operators for the LIKE expression variants (#1096) - Thanks @gruuya * Support "timezone_region" and "timezone_abbr" for `EXTRACT` (and `DATE_PART`) (#1090) - Thanks @alexander-beedie * Support `JSONB` datatype (#1089) - Thanks @alexander-beedie * Support PostgreSQL `^@` starts-with operator (#1091) - Thanks @alexander-beedie * Support PostgreSQL Insert table aliases (#1069) (#1084) - Thanks @boydjohnson * Support PostgreSQL `CREATE EXTENSION` (#1078) - Thanks @tobyhede * Support PostgreSQL `ADD GENERATED` in `ALTER COLUMN` statements (#1079) - Thanks @tobyhede * Support SQLite column definitions with no type (#1075) - Thanks @takluyver * Support PostgreSQL `ENABLE` and `DISABLE` on `ALTER TABLE` (#1077) - Thanks @tobyhede * Support MySQL `FLUSH` statement (#1076) - Thanks @emin100 * Support Mysql `REPLACE` statement and `PRIORITY` clause of `INSERT` (#1072) - Thanks @emin100 ### Fixed * Fix `:start` and `:end` json accesses on SnowFlake (#1110) - Thanks @jmhain * Fix array_agg wildcard behavior (#1093) - Thanks @ReppCodes * Error on dangling `NO` in `CREATE SEQUENCE` options (#1104) - Thanks @PartiallyTyped * Allow string values in `PRAGMA` commands (#1101) - Thanks @invm ### Changed * Use `Option` for Min and Max vals in Seq Opts, fix alter col seq display (#1106) - Thanks @PartiallyTyped * Replace `AtomicUsize` with Cell in the recursion counter (#1098) - Thanks @wzzzzd * Add Qrlew as a user in README.md (#1107) - Thanks @ngrislain * Add APIs to reuse token buffers in `Tokenizer` (#1094) - Thanks @0rphon * Bump version of `sqlparser-derive` to 0.2.2 (#1083) - Thanks @alamb ## [0.41.0] 2023-12-22 ### Added * Support `DEFERRED`, `IMMEDIATE`, and `EXCLUSIVE` in SQLite's `BEGIN TRANSACTION` command (#1067) - Thanks @takaebato * Support generated columns skipping `GENERATED ALWAYS` keywords (#1058) - Thanks @takluyver * Support `LOCK/UNLOCK TABLES` for MySQL (#1059) - Thanks @zzzdong * Support `JSON_TABLE` (#1062) - Thanks @lovasoa * Support `CALL` statements (#1063) - Thanks @lovasoa ### Fixed * fix rendering of SELECT TOP (#1070) for Snowflake - Thanks jmhain ### Changed * Improve documentation formatting (#1068) - Thanks @alamb * Replace type_id() by trait method to allow wrapping dialects (#1065) - Thanks @jjbayer * Document that comments aren't preserved for round trip (#1060) - Thanks @takluyver * Update sqlparser-derive to use `syn 2.0` (#1040) - Thanks @serprex ## [0.40.0] 2023-11-27 ### Added * Add `{pre,post}_visit_query` to `Visitor` (#1044) - Thanks @jmhain * Support generated virtual columns with expression (#1051) - Thanks @takluyver * Support PostgreSQL `END` (#1035) - Thanks @tobyhede * Support `INSERT INTO ... DEFAULT VALUES ...` (#1036) - Thanks @CDThomas * Support `RELEASE` and `ROLLBACK TO SAVEPOINT` (#1045) - Thanks @CDThomas * Support `CONVERT` expressions (#1048) - Thanks @lovasoa * Support `GLOBAL` and `SESSION` parts in `SHOW VARIABLES` for mysql and generic - Thanks @emin100 * Support snowflake `PIVOT` on derived table factors (#1027) - Thanks @lustefaniak * Support mssql json and xml extensions (#1043) - Thanks @lovasoa * Support for `MAX` as a character length (#1038) - Thanks @lovasoa * Support `IN ()` syntax of SQLite (#1028) - Thanks @alamb ### Fixed * Fix extra whitespace printed before `ON CONFLICT` (#1037) - Thanks @CDThomas ### Changed * Document round trip ability (#1052) - Thanks @alamb * Add PRQL to list of users (#1031) - Thanks @vanillajonathan ## [0.39.0] 2023-10-27 ### Added * Support for `LATERAL FLATTEN` and similar (#1026) - Thanks @lustefaniak * Support BigQuery struct, array and bytes , int64, `float64` datatypes (#1003) - Thanks @iffyio * Support numbers as placeholders in Snowflake (e.g. `:1)` (#1001) - Thanks @yuval-illumex * Support date 'key' when using semi structured data (#1023) @yuval-illumex * Support IGNORE|RESPECT NULLs clause in window functions (#998) - Thanks @yuval-illumex * Support for single-quoted identifiers (#1021) - Thanks @lovasoa * Support multiple PARTITION statements in ALTER TABLE ADD statement (#1011) - Thanks @bitemyapp * Support "with" identifiers surrounded by backticks in GenericDialect (#1010) - Thanks @bitemyapp * Support INSERT IGNORE in MySql and GenericDialect (#1004) - Thanks @emin100 * Support SQLite `pragma` statement (#969) - Thanks @marhoily * Support `position` as a column name (#1022) - Thanks @lustefaniak * Support `FILTER` in Functions (for `OVER`) clause (#1007) - Thanks @lovasoa * Support `SELECT * EXCEPT/REPLACE` syntax from ClickHouse (#1013) - Thanks @lustefaniak * Support subquery as function arg w/o parens in Snowflake dialect (#996) - Thanks @jmhain * Support `UNION DISTINCT BY NAME` syntax (#997) - Thanks @alexander-beedie * Support mysql `RLIKE` and `REGEXP` binary operators (#1017) - Thanks @lovasoa * Support bigquery `CAST AS x [STRING|DATE] FORMAT` syntax (#978) - Thanks @lustefaniak * Support Snowflake/BigQuery `TRIM`. (#975) - Thanks @zdenal * Support `CREATE [TEMPORARY|TEMP] VIEW [IF NOT EXISTS] `(#993) - Thanks @gabivlj * Support for `CREATE VIEW … WITH NO SCHEMA BINDING` Redshift (#979) - Thanks @lustefaniak * Support `UNPIVOT` and a fix for chained PIVOTs (#983) - @jmhain * Support for `LIMIT BY` (#977) - Thanks @lustefaniak * Support for mixed BigQuery table name quoting (#971) - Thanks @iffyio * Support `DELETE` with `ORDER BY` and `LIMIT` (MySQL) (#992) - Thanks @ulrichsg * Support `EXTRACT` for `DAYOFWEEK`, `DAYOFYEAR`, `ISOWEEK`, `TIME` (#980) - Thanks @lustefaniak * Support `ATTACH DATABASE` (#989) - Thanks @lovasoa ### Fixed * Fix handling of `/~%` in Snowflake stage name (#1009) - Thanks @lustefaniak * Fix column `COLLATE` not displayed (#1012) - Thanks @lustefaniak * Fix for clippy 1.73 (#995) - Thanks @alamb ### Changed * Test to ensure `+ - * / %` binary operators work the same in all dialects (#1025) - Thanks @lustefaniak * Improve documentation on Parser::consume_token and friends (#994) - Thanks @alamb * Test that regexp can be used as an identifier in postgres (#1018) - Thanks @lovasoa * Add docstrings for Dialects, update README (#1016) - Thanks @alamb * Add JumpWire to users in README (#990) - Thanks @hexedpackets * Add tests for clickhouse: `tokenize == as Token::DoubleEq` (#981)- Thanks @lustefaniak ## [0.38.0] 2023-09-21 ### Added * Support `==`operator for Sqlite (#970) - Thanks @marhoily * Support mysql `PARTITION` to table selection (#959) - Thanks @chunshao90 * Support `UNNEST` as a table factor for PostgreSQL (#968) @hexedpackets * Support MySQL `UNIQUE KEY` syntax (#962) - Thanks @artorias1024 * Support` `GROUP BY ALL` (#964) - @berkaysynnada * Support multiple actions in one ALTER TABLE statement (#960) - Thanks @ForbesLindesay * Add `--sqlite param` to CLI (#956) - Thanks @ddol ### Fixed * Fix Rust 1.72 clippy lints (#957) - Thanks @alamb ### Changed * Add missing token loc in parse err msg (#965) - Thanks @ding-young * Change how `ANY` and `ALL` expressions are represented in AST (#963) - Thanks @SeanTroyUWO * Show location info in parse errors (#958) - Thanks @MartinNowak * Update release documentation (#954) - Thanks @alamb * Break test and coverage test into separate jobs (#949) - Thanks @alamb ## [0.37.0] 2023-08-22 ### Added * Support `FOR SYSTEM_TIME AS OF` table time travel clause support, `visit_table_factor` to Visitor (#951) - Thanks @gruuya * Support MySQL `auto_increment` offset in table definition (#950) - Thanks @ehoeve * Test for mssql table name in square brackets (#952) - Thanks @lovasoa * Support additional Postgres `CREATE INDEX` syntax (#943) - Thanks @ForbesLindesay * Support `ALTER ROLE` syntax of PostgreSQL and MS SQL Server (#942) - Thanks @r4ntix * Support table-level comments (#946) - Thanks @ehoeve * Support `DROP TEMPORARY TABLE`, MySQL syntax (#916) - Thanks @liadgiladi * Support posgres type alias (#933) - Thanks @Kikkon ### Fixed * Clarify the value of the special flag (#948) - Thanks @alamb * Fix `SUBSTRING` from/to argument construction for mssql (#947) - Thanks @jmaness * Fix: use Rust idiomatic capitalization for newly added DataType enums (#939) - Thanks @Kikkon * Fix `BEGIN TRANSACTION` being serialized as `START TRANSACTION` (#935) - Thanks @lovasoa * Fix parsing of datetime functions without parenthesis (#930) - Thanks @lovasoa ## [0.36.1] 2023-07-19 ### Fixed * Fix parsing of identifiers after '%' symbol (#927) - Thanks @alamb ## [0.36.0] 2023-07-19 ### Added * Support toggling "unescape" mode to retain original escaping (#870) - Thanks @canalun * Support UNION (ALL) BY NAME syntax (#915) - Thanks @parkma99 * Add doc comment for all operators (#917) - Thanks @izveigor * Support `PGOverlap` operator (#912) - Thanks @izveigor * Support multi args for unnest (#909) - Thanks @jayzhan211 * Support `ALTER VIEW`, MySQL syntax (#907) - Thanks @liadgiladi * Add DeltaLake keywords (#906) - Thanks @roeap ### Fixed * Parse JsonOperators correctly (#913) - Thanks @izveigor * Fix dependabot by removing rust-toolchain toml (#922) - Thanks @alamb ### Changed * Clean up JSON operator tokenizing code (#923) - Thanks @alamb * Upgrade bigdecimal to 0.4.1 (#921) - Thanks @jinlee0 * Remove most instances of #[cfg(feature(bigdecimal))] in tests (#910) - Thanks @alamb ## [0.35.0] 2023-06-23 ### Added * Support `CREATE PROCEDURE` of MSSQL (#900) - Thanks @delsehi * Support DuckDB's `CREATE MACRO` statements (#897) - Thanks @MartinNowak * Support for `CREATE TYPE (AS)` statements (#888) - Thanks @srijs * Support `STRICT` tables of sqlite (#903) - Thanks @parkma99 ### Fixed * Fixed precedence of unary negation operator with operators: Mul, Div and Mod (#902) - Thanks @izveigor ### Changed * Add `support_group_by_expr` to `Dialect` trait (#896) - Thanks @jdye64 * Update criterion requirement from `0.4` to `0.5` in `/sqlparser_bench` (#890) - Thanks @dependabot (!!) ## [0.34.0] 2023-05-19 ### Added * Support named window frames (#881) - Thanks @berkaysynnada, @mustafasrepo, and @ozankabak * Support for `ORDER BY` clauses in aggregate functions (#882) - Thanks @mustafasrepo * Support `DuckDB` dialect (#878) - Thanks @eitsupi * Support optional `TABLE` keyword for `TRUNCATE TABLE` (#883) - Thanks @mobuchowski * Support MySQL's `DIV` operator (#876) - Thanks @eitsupi * Support Custom operators (#868) - Thanks @max-sixty * Add `Parser::parse_multipart_identifier` (#860) - Thanks @Jefffrey * Support for multiple expressions, order by in `ARRAY_AGG` (#879) - Thanks @mustafasrepo * Support for query source in `COPY .. TO` statement (#858) - Thanks @aprimadi * Support `DISTINCT ON (...)` (#852) - Thanks @aljazerzen * Support multiple-table `DELETE` syntax (#855) - Thanks @AviRaboah * Support `COPY INTO` in `SnowflakeDialect` (#841) - Thanks @pawel-big-lebowski * Support identifiers beginning with digits in MySQL (#856) - Thanks @AviRaboah ### Changed * Include license file in published crate (#871) - Thanks @ankane * Make `Expr::Interval` its own struct (#872) - Thanks @aprimadi * Add dialect_from_str and improve Dialect documentation (#848) - Thanks @alamb * Add clickhouse to example (#849) - Thanks @anglinb ### Fixed * Fix merge conflict (#885) - Thanks @alamb * Fix tiny typo in custom_sql_parser.md (#864) - Thanks @okue * Fix logical merge conflict (#865) - Thanks @alamb * Test trailing commas (#859) - Thanks @aljazerzen ## [0.33.0] 2023-04-10 ### Added * Support for Mysql Backslash escapes (enabled by default) (#844) - Thanks @cobyge * Support "UPDATE" statement in "WITH" subquery (#842) - Thanks @nicksrandall * Support PIVOT table syntax (#836) - Thanks @pawel-big-lebowski * Support CREATE/DROP STAGE for Snowflake (#833) - Thanks @pawel-big-lebowski * Support Non-Latin characters (#840) - Thanks @mskrzypkows * Support PostgreSQL: GENERATED { ALWAYS | BY DEFAULT } AS IDENTITY and GENERATED - Thanks @sam-mmm * Support IF EXISTS in COMMENT statements (#831) - Thanks @pawel-big-lebowski * Support snowflake alter table swap with (#825) - Thanks @pawel-big-lebowski ### Changed * Move tests from parser.rs to appropriate parse_XX tests (#845) - Thanks @alamb * Correct typos in parser.rs (#838) - Thanks @felixonmars * Improve documentation on verified_* methods (#828) - Thanks @alamb ## [0.32.0] 2023-03-6 ### Added * Support ClickHouse `CREATE TABLE` with `ORDER BY` (#824) - Thanks @ankrgyl * Support PostgreSQL exponentiation `^` operator (#813) - Thanks @michael-2956 * Support `BIGNUMERIC` type in BigQuery (#811) - Thanks @togami2864 * Support for optional trailing commas (#810) - Thanks @ankrgyl ### Fixed * Fix table alias parsing regression by backing out redshift column definition list (#827) - Thanks @alamb * Fix typo in `ReplaceSelectElement` `colum_name` --> `column_name` (#822) - Thanks @togami2864 ## [0.31.0] 2023-03-1 ### Added * Support raw string literals for BigQuery dialect (#812) - Thanks @togami2864 * Support `SELECT * REPLACE AS ` in BigQuery dialect (#798) - Thanks @togami2864 * Support byte string literals for BigQuery dialect (#802) - Thanks @togami2864 * Support columns definition list for system information functions in RedShift dialect (#769) - Thanks @mskrzypkows * Support `TRANSIENT` keyword in Snowflake dialect (#807) - Thanks @mobuchowski * Support `JSON` keyword (#799) - Thanks @togami2864 * Support MySQL Character Set Introducers (#788) - Thanks @mskrzypkows ### Fixed * Fix clippy error in ci (#803) - Thanks @togami2864 * Handle offset in map key in BigQuery dialect (#797) - Thanks @Ziinc * Fix a typo (precendence -> precedence) (#794) - Thanks @SARDONYX-sard * use post_* visitors for mutable visits (#789) - Thanks @lovasoa ### Changed * Add another known user (#787) - Thanks @joocer ## [0.30.0] 2023-01-02 ### Added * Support `RENAME` for wildcard `SELECTs` (#784) - Thanks @Jefffrey * Add a mutable visitor (#782) - Thanks @lovasoa ### Changed * Allow parsing of mysql empty row inserts (#783) - Thanks @Jefffrey ### Fixed * Fix logical conflict (#785) - Thanks @alamb ## [0.29.0] 2022-12-29 ### Highlights * Partial source location tracking: see #710 * Recursion limit to prevent stack overflows: #764 * AST visitor: #765 ### Added feat: dollar-quoted strings support (#772) - Thanks @vasilev-alex * Add derive based AST visitor (#765) - Thanks @tustvold * Support `ALTER INDEX {INDEX_NAME} RENAME TO {NEW_INDEX_NAME}` (#767) - Thanks @devgony * Support `CREATE TABLE ON UPDATE ` Function (#685) - Thanks @CEOJINSUNG * Support `CREATE FUNCTION` definition with `$$` (#755)- Thanks @zidaye * Add location tracking in the tokenizer and parser (#710) - Thanks @ankrgyl * Add configurable recursion limit to parser, to protect against stackoverflows (#764) - Thanks @alamb * Support parsing scientific notation (such as `10e5`) (#768) - Thanks @Jefffrey * Support `DROP FUNCTION` syntax (#752) - Thanks @zidaye * Support json operators `@>` `<@`, `@?` and `@@` - Thanks @audunska * Support the type key (#750)- Thanks @yuval-illumex ### Changed * Improve docs and add examples for Visitor (#778) - Thanks @alamb * Add a backlink from sqlparse_derive to sqlparser and publishing instructions (#779) - Thanks @alamb * Document new features, update authors (#776) - Thanks @alamb * Improve Readme (#774) - Thanks @alamb * Standardize comments on parsing optional keywords (#773) - Thanks @alamb * Enable grouping sets parsing for `GenericDialect` (#771) - Thanks @Jefffrey * Generalize conflict target (#762) - Thanks @audunska * Generalize locking clause (#759) - Thanks @audunska * Add negative test for except clause on wildcards (#746)- Thanks @alamb * Add `NANOSECOND` keyword (#749)- Thanks @waitingkuo ### Fixed * ParserError if nested explain (#781) - Thanks @Jefffrey * Fix cargo docs / warnings and add CI check (#777) - Thanks @alamb * unnest join constraint with alias parsing for BigQuery dialect (#732)- Thanks @Ziinc ## [0.28.0] 2022-12-05 ### Added * Support for `EXCEPT` clause on wildcards (#745) - Thanks @AugustoFKL * Support `CREATE FUNCTION` Postgres options (#722) - Thanks @wangrunji0408 * Support `CREATE TABLE x AS TABLE y` (#704) - Thanks @sarahyurick * Support MySQL `ROWS` syntax for `VALUES` (#737) - Thanks @aljazerzen * Support `WHERE` condition for `UPDATE ON CONFLICT` (#735) - Thanks @zidaye * Support `CLUSTER BY` when creating Materialized View (#736) - Thanks @yuval-illumex * Support nested comments (#726) - Thanks @yang-han * Support `USING` method when creating indexes. (#731) - Thanks @step-baby and @yangjiaxin01 * Support `SEMI`/`ANTI` `JOIN` syntax (#723) - Thanks @mingmwang * Support `EXCLUDE` support for snowflake and generic dialect (#721) - Thanks @AugustoFKL * Support `MATCH AGAINST` (#708) - Thanks @AugustoFKL * Support `IF NOT EXISTS` in `ALTER TABLE ADD COLUMN` (#707) - Thanks @AugustoFKL * Support `SET TIME ZONE ` (#727) - Thanks @waitingkuo * Support `UPDATE ... FROM ( subquery )` (#694) - Thanks @unvalley ### Changed * Add `Parser::index()` method to get current parsing index (#728) - Thanks @neverchanje * Add `COMPRESSION` as keyword (#720)- Thanks @AugustoFKL * Derive `PartialOrd`, `Ord`, and `Copy` whenever possible (#717) - Thanks @AugustoFKL * Fixed `INTERVAL` parsing logic and precedence (#705) - Thanks @sarahyurick * Support updating multiple column names whose names are the same as(#725) - Thanks @step-baby ### Fixed * Clean up some redundant code in parser (#741) - Thanks @alamb * Fix logical conflict - Thanks @alamb * Cleanup to avoid is_ok() (#740) - Thanks @alamb * Cleanup to avoid using unreachable! when parsing semi/anti join (#738) - Thanks @alamb * Add an example to docs to clarify semantic analysis (#739) - Thanks @alamb * Add information about parting semantic logic to README.md (#724) - Thanks @AugustoFKL * Logical conflicts - Thanks @alamb * Tiny typo in docs (#709) - Thanks @pmcgee69 ## [0.27.0] 2022-11-11 ### Added * Support `ON CONFLICT` and `RETURNING` in `UPDATE` statement (#666) - Thanks @main and @gamife * Support `FULLTEXT` option on create table for MySQL and Generic dialects (#702) - Thanks @AugustoFKL * Support `ARRAY_AGG` for Bigquery and Snowflake (#662) - Thanks @SuperBo * Support DISTINCT for SetOperator (#689) - Thanks @unvalley * Support the ARRAY type of Snowflake (#699) - Thanks @yuval-illumex * Support create sequence with options INCREMENT, MINVALUE, MAXVALUE, START etc. (#681) - Thanks @sam-mmm * Support `:` operator for semi-structured data in Snowflake(#693) - Thanks @yuval-illumex * Support ALTER TABLE DROP PRIMARY KEY (#682) - Thanks @ding-young * Support `NUMERIC` and `DEC` ANSI data types (#695) - Thanks @AugustoFKL * Support modifiers for Custom Datatype (#680) - Thanks @sunng87 ### Changed * Add precision for TIME, DATETIME, and TIMESTAMP data types (#701) - Thanks @AugustoFKL * add Date keyword (#691) - Thanks @sarahyurick * Update simple_logger requirement from 2.1 to 4.0 - Thanks @dependabot ### Fixed * Fix broken DataFusion link (#703) - Thanks @jmg-duarte * Add MySql, BigQuery to all dialects tests, fixed bugs (#697) - Thanks @omer-shtivi ## [0.26.0] 2022-10-19 ### Added * Support MySQL table option `{INDEX | KEY}` in CREATE TABLE definiton (#665) - Thanks @AugustoFKL * Support `CREATE [ { TEMPORARY | TEMP } ] SEQUENCE [ IF NOT EXISTS ] ` (#678) - Thanks @sam-mmm * Support `DROP SEQUENCE` statement (#673) - Thanks @sam-mmm * Support for ANSI types `CHARACTER LARGE OBJECT[(p)]` and `CHAR LARGE OBJECT[(p)]` (#671) - Thanks @AugustoFKL * Support `[CACHE|UNCACHE] TABLE` (#670) - Thanks @francis-du * Support `CEIL(expr TO DateTimeField)` and `FLOOR(expr TO DateTimeField)` - Thanks @sarahyurick * Support all ansii character string types, (#648) - Thanks @AugustoFKL ### Changed * Support expressions inside window frames (#655) - Thanks @mustafasrepo and @ozankabak * Support unit on char length units for small character strings (#663) - Thanks @AugustoFKL * Replace booleans on `SET ROLE` with a single enum. (#664) - Thanks @AugustoFKL * Replace `Option`s with enum for `DECIMAL` precision (#654) - Thanks @AugustoFKL ## [0.25.0] 2022-10-03 ### Added * Support `AUTHORIZATION` clause in `CREATE SCHEMA` statements (#641) - Thanks @AugustoFKL * Support optional precision for `CLOB` and `BLOB` (#639) - Thanks @AugustoFKL * Support optional precision in `VARBINARY` and `BINARY` (#637) - Thanks @AugustoFKL ### Changed * `TIMESTAMP` and `TIME` parsing preserve zone information (#646) - Thanks @AugustoFKL ### Fixed * Correct order of arguments when parsing `LIMIT x,y` , restrict to `MySql` and `Generic` dialects - Thanks @AugustoFKL ## [0.24.0] 2022-09-29 ### Added * Support `MILLENNIUM` (2 Ns) (#633) - Thanks @sarahyurick * Support `MEDIUMINT` (#630) - Thanks @AugustoFKL * Support `DOUBLE PRECISION` (#629) - Thanks @AugustoFKL * Support precision in `CLOB`, `BINARY`, `VARBINARY`, `BLOB` data type (#618) - Thanks @ding-young * Support `CREATE ROLE` and `DROP ROLE` (#598) - Thanks @blx * Support full range of sqlite prepared statement placeholders (#604) - Thanks @lovasoa * Support National string literal with lower case `n` (#612) - Thanks @mskrzypkows * Support SHOW FUNCTIONS (#620) - Thanks @joocer * Support `set time zone to 'some-timezone'` (#617) - Thanks @waitingkuo ### Changed * Move `Value::Interval` to `Expr::Interval` (#609) - Thanks @ding-young * Update `criterion` dev-requirement from 0.3 to 0.4 in /sqlparser_bench (#611) - Thanks @dependabot * Box `Query` in `Cte` (#572) - Thanks @MazterQyou ### Other * Disambiguate CREATE ROLE ... USER and GROUP (#628) - Thanks @alamb * Add test for optional WITH in CREATE ROLE (#627) - Thanks @alamb ## [0.23.0] 2022-09-08 ### Added * Add support for aggregate expressions with filters (#585) - Thanks @andygrove * Support `LOCALTIME` and `LOCALTIMESTAMP` time functions (#592) - Thanks @MazterQyou ## [0.22.0] 2022-08-26 ### Added * Support `OVERLAY` expressions (#594) - Thanks @ayushg * Support `WITH TIMEZONE` and `WITHOUT TIMEZONE` when parsing `TIMESTAMP` expressions (#589) - Thanks @waitingkuo * Add ability for dialects to override prefix, infix, and statement parsing (#581) - Thanks @andygrove ## [0.21.0] 2022-08-18 ### Added * Support `IS [NOT] TRUE`, `IS [NOT] FALSE`, and `IS [NOT] UNKNOWN` - Thanks (#583) @sarahyurick * Support `SIMILAR TO` syntax (#569) - Thanks @ayushdg * Support `SHOW COLLATION` (#564) - Thanks @MazterQyou * Support `SHOW TABLES` (#563) - Thanks @MazterQyou * Support `SET NAMES literal [COLLATE literal]` (#558) - Thanks @ovr * Support trailing commas (#557) in `BigQuery` dialect - Thanks @komukomo * Support `USE ` (#565) - Thanks @MazterQyou * Support `SHOW COLUMNS FROM tbl FROM db` (#562) - Thanks @MazterQyou * Support `SHOW VARIABLES` for `MySQL` dialect (#559) - Thanks @ovr and @vasilev-alex ### Changed * Support arbitrary expression in `SET` statement (#574) - Thanks @ovr and @vasilev-alex * Parse LIKE patterns as Expr not Value (#579) - Thanks @andygrove * Update Ballista link in README (#576) - Thanks @sanxiyn * Parse `TRIM` from with optional expr and `FROM` expr (#573) - Thanks @ayushdg * Support PostgreSQL array subquery constructor (#566) - Thanks @MazterQyou * Clarify contribution licensing (#570) - Thanks @alamb * Update for new clippy ints (#571) - Thanks @alamb * Change `Like` and `ILike` to `Expr` variants, allow escape char (#569) - Thanks @ayushdg * Parse special keywords as functions (`current_user`, `user`, etc) (#561) - Thanks @ovr * Support expressions in `LIMIT`/`OFFSET` (#567) - Thanks @MazterQyou ## [0.20.0] 2022-08-05 ### Added * Support custom `OPERATOR` postgres syntax (#548) - Thanks @iskakaushik * Support `SAFE_CAST` for BigQuery (#552) - Thanks @togami2864 ### Changed * Added SECURITY.md (#546) - Thanks @JamieSlome * Allow `>>` and `<<` binary operators in Generic dialect (#553) - Thanks @ovr * Allow `NestedJoin` with an alias (#551) - Thanks @waitingkuo ## [0.19.0] 2022-07-28 ### Added * Support `ON CLUSTER` for `CREATE TABLE` statement (ClickHouse DDL) (#527) - Thanks @andyrichardson * Support empty `ARRAY` literals (#532) - Thanks @bitemyapp * Support `AT TIME ZONE` clause (#539) - Thanks @bitemyapp * Support `USING` clause and table aliases in `DELETE` (#541) - Thanks @mobuchowski * Support `SHOW CREATE VIEW` statement (#536) - Thanks @mrob95 * Support `CLONE` clause in `CREATE TABLE` statements (#542) - Thanks @mobuchowski * Support `WITH OFFSET Alias` in table references (#528) - Thanks @sivchari * Support double quoted (`"`) literal strings: (#530) - Thanks @komukomo * Support `ON UPDATE` clause on column definitions in `CREATE TABLE` statements (#522) - Thanks @frolovdev ### Changed: * `Box`ed `Query` body to save stack space (#540) - Thanks @5tan * Distinguish between `INT` and `INTEGER` types (#525) - Thanks @frolovdev * Parse `WHERE NOT EXISTS` as `Expr::Exists` rather than `Expr::UnaryOp` for consistency (#523) - Thanks @frolovdev * Support `Expr` instead of `String` for argument to `INTERVAL` (#517) - Thanks @togami2864 ### Fixed: * Report characters instead of bytes in error messages (#529) - Thanks @michael-2956 ## [0.18.0] 2022-06-06 ### Added * Support `CLOSE` (cursors) (#515) - Thanks @ovr * Support `DECLARE` (cursors) (#509) - Thanks @ovr * Support `FETCH` (cursors) (#510) - Thanks @ovr * Support `DATETIME` keyword (#512) - Thanks @komukomo * Support `UNNEST` as a table factor (#493) - Thanks @sivchari * Support `CREATE FUNCTION` (hive flavor) (#496) - Thanks @mobuchowski * Support placeholders (`$` or `?`) in `LIMIT` clause (#494) - Thanks @step-baby * Support escaped string literals (PostgreSQL) (#502) - Thanks @ovr * Support `IS TRUE` and `IS FALSE` (#499) - Thanks @ovr * Support `DISCARD [ALL | PLANS | SEQUENCES | TEMPORARY | TEMP]` (#500) - Thanks @gandronchik * Support `array<..>` HIVE data types (#491) - Thanks @mobuchowski * Support `SET` values that begin with `-` #495 - Thanks @mobuchowski * Support unicode whitespace (#482) - Thanks @alexsatori * Support `BigQuery` dialect (#490) - Thanks @komukomo ### Changed: * Add docs for MapAccess (#489) - Thanks @alamb * Rename `ArrayIndex::indexs` to `ArrayIndex::indexes` (#492) - Thanks @alamb ### Fixed: * Fix escaping of trailing quote in quoted identifiers (#505) - Thanks @razzolini-qpq * Fix parsing of `COLLATE` after parentheses in expressions (#507) - Thanks @razzolini-qpq * Distinguish tables and nullary functions in `FROM` (#506) - Thanks @razzolini-qpq * Fix `MERGE INTO` semicolon handling (#508) - Thanks @mskrzypkows ## [0.17.0] 2022-05-09 ### Added * Support `#` as first character in field name for `RedShift` dialect (#485) - Thanks @yuval-illumex * Support for postgres composite types (#466) - Thanks @poonai * Support `TABLE` keyword with SELECT INTO (#487) - Thanks @MazterQyou * Support `ANY`/`ALL` operators (#477) - Thanks @ovr * Support `ArrayIndex` in `GenericDialect` (#480) - Thanks @ovr * Support `Redshift` dialect, handle square brackets properly (#471) - Thanks @mskrzypkows * Support `KILL` statement (#479) - Thanks @ovr * Support `QUALIFY` clause on `SELECT` for `Snowflake` dialect (#465) - Thanks @mobuchowski * Support `POSITION(x IN y)` function syntax (#463) @yuval-illumex * Support `global`,`local`, `on commit` for `create temporary table` (#456) - Thanks @gandronchik * Support `NVARCHAR` data type (#462) - Thanks @yuval-illumex * Support for postgres json operators `->`, `->>`, `#>`, and `#>>` (#458) - Thanks @poonai * Support `SET ROLE` statement (#455) - Thanks @slhmy ### Changed: * Improve docstrings for `KILL` statement (#481) - Thanks @alamb * Add negative tests for `POSITION` (#469) - Thanks @alamb * Add negative tests for `IN` parsing (#468) - Thanks @alamb * Suppport table names (as well as subqueries) as source in `MERGE` statements (#483) - Thanks @mskrzypkows ### Fixed: * `INTO` keyword is optional for `INSERT`, `MERGE` (#473) - Thanks @mobuchowski * Support `IS TRUE` and `IS FALSE` expressions in boolean filter (#474) - Thanks @yuval-illumex * Support fully qualified object names in `SET VARIABLE` (#484) - Thanks mobuchowski ## [0.16.0] 2022-04-03 ### Added * Support `WEEK` keyword in `EXTRACT` (#436) - Thanks @Ted-Jiang * Support `MERGE` statement (#430) - Thanks @mobuchowski * Support `SAVEPOINT` statement (#438) - Thanks @poonai * Support `TO` clause in `COPY` (#441) - Thanks @matthewmturner * Support `CREATE DATABASE` statement (#451) - Thanks @matthewmturner * Support `FROM` clause in `UPDATE` statement (#450) - Thanks @slhmy * Support additional `COPY` options (#446) - Thanks @wangrunji0408 ### Fixed: * Bug in array / map access parsing (#433) - Thanks @monadbobo ## [0.15.0] 2022-03-07 ### Added * Support for ClickHouse array types (e.g. [1,2,3]) (#429) - Thanks @monadbobo * Support for `unsigned tinyint`, `unsigned int`, `unsigned smallint` and `unsigned bigint` datatypes (#428) - Thanks @watarukura * Support additional keywords for `EXTRACT` (#427) - Thanks @mobuchowski * Support IN UNNEST(expression) (#426) - Thanks @komukomo * Support COLLATION keywork on CREATE TABLE (#424) - Thanks @watarukura * Support FOR UPDATE/FOR SHARE clause (#418) - Thanks @gamife * Support prepared statement placeholder arg `?` and `$` (#420) - Thanks @gamife * Support array expressions such as `ARRAY[1,2]` , `foo[1]` and `INT[][]` (#419) - Thanks @gamife ### Changed: * remove Travis CI (#421) - Thanks @efx ### Fixed: * Allow `array` to be used as a function name again (#432) - @alamb * Update docstring reference to `Query` (#423) - Thanks @max-sixty ## [0.14.0] 2022-02-09 ### Added * Support `CURRENT_TIMESTAMP`, `CURRENT_TIME`, and `CURRENT_DATE` (#391) - Thanks @yuval-illumex * SUPPORT `SUPER` keyword (#387) - Thanks @flaneur2020 * Support differing orders of `OFFSET` `LIMIT` as well as `LIMIT` `OFFSET` (#413) - Thanks @yuval-illumex * Support for `FROM `, `DELIMITER`, and `CSV HEADER` options for `COPY` command (#409) - Thanks @poonai * Support `CHARSET` and `ENGINE` clauses on `CREATE TABLE` for mysql (#392) - Thanks @antialize * Support `DROP CONSTRAINT [ IF EXISTS ] [ CASCADE ]` (#396) - Thanks @tvallotton * Support parsing tuples and add `Expr::Tuple` (#414) - @alamb * Support MySQL style `LIMIT X, Y` (#415) - @alamb * Support `SESSION TRANSACTION` and `TRANSACTION SNAPSHOT`. (#379) - Thanks @poonai * Support `ALTER COLUMN` and `RENAME CONSTRAINT` (#381) - Thanks @zhamlin * Support for Map access, add ClickHouse dialect (#382) - Thanks @monadbobo ### Changed * Restrict where wildcard (`*`) can appear, add to `FunctionArgExpr` remove `Expr::[Qualified]Wildcard`, (#378) - Thanks @panarch * Update simple_logger requirement from 1.9 to 2.1 (#403) * export all methods of parser (#397) - Thanks @neverchanje! * Clarify maintenance status on README (#416) - @alamb ### Fixed * Fix new clippy errors (#412) - @alamb * Fix panic with `GRANT/REVOKE` in `CONNECT`, `CREATE`, `EXECUTE` or `TEMPORARY` - Thanks @evgenyx00 * Handle double quotes inside quoted identifiers correctly (#411) - Thanks @Marwes * Handle mysql backslash escaping (#373) - Thanks @vasilev-alex ## [0.13.0] 2021-12-10 ### Added * Add ALTER TABLE CHANGE COLUMN, extend the UPDATE statement with ON clause (#375) - Thanks @0xA537FD! * Add support for GROUPIING SETS, ROLLUP and CUBE - Thanks @Jimexist! * Add basic support for GRANT and REVOKE (#365) - Thanks @blx! ### Changed * Use Rust 2021 edition (#368) - Thanks @Jimexist! ### Fixed * Fix clippy errors (#367, #374) - Thanks @Jimexist! ## [0.12.0] 2021-10-14 ### Added * Add support for [NOT] IS DISTINCT FROM (#306) - @Dandandan ### Changed * Move the keywords module - Thanks @koushiro! ## [0.11.0] 2021-09-24 ### Added * Support minimum display width for integer data types (#337) Thanks @vasilev-alex! * Add logical XOR operator (#357) - Thanks @xzmrdltl! * Support DESCRIBE table_name (#340) - Thanks @ovr! * Support SHOW CREATE TABLE|EVENT|FUNCTION (#338) - Thanks @ovr! * Add referential actions to TableConstraint foreign key (#306) - Thanks @joshwd36! ### Changed * Enable map access for numbers, multiple nesting levels (#356) - Thanks @Igosuki! * Rename Token::Mult to Token::Mul (#353) - Thanks @koushiro! * Use derive(Default) for HiveFormat (#348) - Thanks @koushiro! * Improve tokenizer error (#347) - Thanks @koushiro! * Eliminate redundant string copy in Tokenizer (#343) - Thanks @koushiro! * Update bigdecimal requirement from 0.2 to 0.3 dependencies (#341) * Support parsing hexadecimal literals that start with `0x` (#324) - Thanks @TheSchemm! ## [0.10.0] 2021-08-23 ### Added * Support for `no_std` (#332) - Thanks @koushiro! * Postgres regular expression operators (`~`, `~*`, `!~`, `!~*`) (#328) - Thanks @b41sh! * tinyint (#320) - Thanks @sundy-li * ILIKE (#300) - Thanks @maxcountryman! * TRIM syntax (#331, #334) - Thanks ever0de ### Fixed * Return error instead of panic (#316) - Thanks @BohuTANG! ### Changed - Rename `Modulus` to `Modulo` (#335) - Thanks @RGRAVITY817! - Update links to reflect repository move to `sqlparser-rs` GitHub org (#333) - Thanks @andygrove - Add default value for `WindowFrame` (#313) - Thanks @Jimexist! ## [0.9.0] 2021-03-21 ### Added * Add support for `TRY_CAST` syntax (#299) - Thanks @seddonm1! ## [0.8.0] 2021-02-20 ### Added * Introduce Hive QL dialect `HiveDialect` and syntax (#235) - Thanks @hntd187! * Add `SUBSTRING(col [FROM ] [FOR ])` syntax (#293) * Support parsing floats without leading digits `.01` (#294) * Support parsing multiple show variables (#290) - Thanks @francis-du! * Support SQLite `INSERT OR [..]` syntax (#281) - Thanks @zhangli-pear! ## [0.7.0] 2020-12-28 ### Changed - Change the MySQL dialect to support `` `identifiers` `` quoted with backticks instead of the standard `"double-quoted"` identifiers (#247) - thanks @mashuai! - Update bigdecimal requirement from 0.1 to 0.2 (#268) ### Added - Enable dialect-specific behaviours in the parser (`dialect_of!()`) (#254) - thanks @eyalleshem! - Support named arguments in function invocations (`ARG_NAME => val`) (#250) - thanks @eyalleshem! - Support `TABLE()` functions in `FROM` (#253) - thanks @eyalleshem! - Support Snowflake's single-line comments starting with '#' or '//' (#264) - thanks @eyalleshem! - Support PostgreSQL `PREPARE`, `EXECUTE`, and `DEALLOCATE` (#243) - thanks @silathdiir! - Support PostgreSQL math operators (#267) - thanks @alex-dukhno! - Add SQLite dialect (#248) - thanks @mashuai! - Add Snowflake dialect (#259) - thanks @eyalleshem! - Support for Recursive CTEs - thanks @rhanqtl! - Support `FROM (table_name) alias` syntax - thanks @eyalleshem! - Support for `EXPLAIN [ANALYZE] VERBOSE` - thanks @ovr! - Support `ANALYZE TABLE` - DDL: - Support `OR REPLACE` in `CREATE VIEW`/`TABLE` (#239) - thanks @Dandandan! - Support specifying `ASC`/`DESC` in index columns (#249) - thanks @mashuai! - Support SQLite `AUTOINCREMENT` and MySQL `AUTO_INCREMENT` column option in `CREATE TABLE` (#234) - thanks @mashuai! - Support PostgreSQL `IF NOT EXISTS` for `CREATE SCHEMA` (#276) - thanks @alex-dukhno! ### Fixed - Fix a typo in `JSONFILE` serialization, introduced in 0.3.1 (#237) - Change `CREATE INDEX` serialization to not end with a semicolon, introduced in 0.5.1 (#245) - Don't fail parsing `ALTER TABLE ADD COLUMN` ending with a semicolon, introduced in 0.5.1 (#246) - thanks @mashuai ## [0.6.1] - 2020-07-20 ### Added - Support BigQuery `ASSERT` statement (#226) ## [0.6.0] - 2020-07-20 ### Added - Support SQLite's `CREATE TABLE (...) WITHOUT ROWID` (#208) - thanks @mashuai! - Support SQLite's `CREATE VIRTUAL TABLE` (#209) - thanks @mashuai! ## [0.5.1] - 2020-06-26 This release should have been called `0.6`, as it introduces multiple incompatible changes to the API. If you don't want to upgrade yet, you can revert to the previous version by changing your `Cargo.toml` to: sqlparser = "= 0.5.0" ### Changed - **`Parser::parse_sql` now accepts a `&str` instead of `String` (#182)** - thanks @Dandandan! - Change `Ident` (previously a simple `String`) to store the parsed (unquoted) `value` of the identifier and the `quote_style` separately (#143) - thanks @apparebit! - Support Snowflake's `FROM (table_name)` (#155) - thanks @eyalleshem! - Add line and column number to TokenizerError (#194) - thanks @Dandandan! - Use Token::EOF instead of Option (#195) - Make the units keyword following `INTERVAL '...'` optional (#184) - thanks @maxcountryman! - Generalize `DATE`/`TIME`/`TIMESTAMP` literals representation in the AST (`TypedString { data_type, value }`) and allow `DATE` and other keywords to be used as identifiers when not followed by a string (#187) - thanks @maxcountryman! - Output DataType capitalized (`fmt::Display`) (#202) - thanks @Dandandan! ### Added - Support MSSQL `TOP () [ PERCENT ] [ WITH TIES ]` (#150) - thanks @alexkyllo! - Support MySQL `LIMIT row_count OFFSET offset` (not followed by `ROW` or `ROWS`) and remember which variant was parsed (#158) - thanks @mjibson! - Support PostgreSQL `CREATE TABLE IF NOT EXISTS table_name` (#163) - thanks @alex-dukhno! - Support basic forms of `CREATE INDEX` and `DROP INDEX` (#167) - thanks @mashuai! - Support `ON { UPDATE | DELETE } { RESTRICT | CASCADE | SET NULL | NO ACTION | SET DEFAULT }` in `FOREIGN KEY` constraints (#170) - thanks @c7hm4r! - Support basic forms of `CREATE SCHEMA` and `DROP SCHEMA` (#173) - thanks @alex-dukhno! - Support `NULLS FIRST`/`LAST` in `ORDER BY` expressions (#176) - thanks @houqp! - Support `LISTAGG()` (#174) - thanks @maxcountryman! - Support the string concatentation operator `||` (#178) - thanks @Dandandan! - Support bitwise AND (`&`), OR (`|`), XOR (`^`) (#181) - thanks @Dandandan! - Add serde support to AST structs and enums (#196) - thanks @panarch! - Support `ALTER TABLE ADD COLUMN`, `RENAME COLUMN`, and `RENAME TO` (#203) - thanks @mashuai! - Support `ALTER TABLE DROP COLUMN` (#148) - thanks @ivanceras! - Support `CREATE TABLE ... AS ...` (#206) - thanks @Dandandan! ### Fixed - Report an error for unterminated string literals (#165) - Make file format (`STORED AS`) case insensitive (#200) and don't allow quoting it (#201) - thanks @Dandandan! ## [0.5.0] - 2019-10-10 ### Changed - Replace the `Value::Long(u64)` and `Value::Double(f64)` variants with `Value::Number(String)` to avoid losing precision when parsing decimal literals (#130) - thanks @benesch! - `--features bigdecimal` can be enabled to work with `Value::Number(BigDecimal)` instead, at the cost of an additional dependency. ### Added - Support MySQL `SHOW COLUMNS`, `SET =`, and `SHOW ` statements (#135) - thanks @quodlibetor and @benesch! ### Fixed - Don't fail to parse `START TRANSACTION` followed by a semicolon (#139) - thanks @gaffneyk! ## [0.4.0] - 2019-07-02 This release brings us closer to SQL-92 support, mainly thanks to the improvements contributed back from @MaterializeInc's fork and other work by @benesch. ### Changed - Remove "SQL" from type and enum variant names, `SQLType` -> `DataType`, remove "sql" prefix from module names (#105, #122) - Rename `ASTNode` -> `Expr` (#119) - Improve consistency of binary/unary op nodes (#112): - `ASTNode::SQLBinaryExpr` is now `Expr::BinaryOp` and `ASTNode::SQLUnary` is `Expr::UnaryOp`; - The `op: SQLOperator` field is now either a `BinaryOperator` or an `UnaryOperator`. - Change the representation of JOINs to match the standard (#109): `SQLSelect`'s `relation` and `joins` are replaced with `from: Vec`. Before this change `FROM foo NATURAL JOIN bar, baz` was represented as "foo" as the `relation` followed by two joins (`Inner(Natural)` and `Implicit`); now it's two `TableWithJoins` (`foo NATURAL JOIN bar` and `baz`). - Extract a `SQLFunction` struct (#89) - Replace `Option>` with `Vec` in the AST structs (#73) - Change `Value::Long()` to be unsigned, use u64 consistently (#65) ### Added - Infra: - Implement `fmt::Display` on AST nodes (#124) - thanks @vemoo! - Implement `Hash` (#88) and `Eq` (#123) on all AST nodes - Implement `std::error::Error` for `ParserError` (#72) - Handle Windows line-breaks (#54) - Expressions: - Support `INTERVAL` literals (#103) - Support `DATE` / `TIME` / `TIMESTAMP` literals (#99) - Support `EXTRACT` (#96) - Support `X'hex value'` literals (#95) - Support `EXISTS` subqueries (#90) - Support nested expressions in `BETWEEN` (#80) - Support `COUNT(DISTINCT x)` and similar (#77) - Support `CASE operand WHEN expected_value THEN ..` and table-valued functions (#59) - Support analytic (window) functions (`OVER` clause) (#50) - Queries / DML: - Support nested joins (#100) and derived tables with set operations (#111) - Support `UPDATE` statements (#97) - Support `INSERT INTO foo SELECT * FROM bar` and `FROM VALUES (...)` (#91) - Support `SELECT ALL` (#76) - Add `FETCH` and `OFFSET` support, and `LATERAL` (#69) - thanks @thomas-jeepe! - Support `COLLATE`, optional column list in CTEs (#64) - DDL/TCL: - Support `START/SET/COMMIT/ROLLBACK TRANSACTION` (#106) - thanks @SamuelMarks! - Parse column constraints in any order (#93) - Parse `DECIMAL` and `DEC` aliases for `NUMERIC` type (#92) - Support `DROP [TABLE|VIEW]` (#75) - Support arbitrary `WITH` options for `CREATE [TABLE|VIEW]` (#74) - Support constraints in `CREATE TABLE` (#65) - Add basic MSSQL dialect (#61) and some MSSQL-specific features: - `CROSS`/`OUTER APPLY` (#120) - MSSQL identifier and alias parsing rules (#66) - `WITH` hints (#59) ### Fixed - Report an error for `SELECT * FROM a OUTER JOIN b` instead of parsing `OUTER` as an alias (#118) - Fix the precedence of `NOT LIKE` (#82) and unary `NOT` (#107) - Do not panic when `NOT` is not followed by an expected keyword (#71) successfully instead of returning a parse error - thanks @ivanceras! (#67) - and similar fixes for queries with no `FROM` (#116) - Fix issues with `ALTER TABLE ADD CONSTRAINT` parsing (#65) - Serialize the "not equals" operator as `<>` instead of `!=` (#64) - Remove dependencies on `uuid` (#59) and `chrono` (#61) - Make `SELECT` query with `LIMIT` clause but no `WHERE` parse - Fix incorrect behavior of `ASTNode::SQLQualifiedWildcard::to_string()` (returned `foo*` instead of `foo.*`) - thanks @thomas-jeepe! (#52) ## [0.3.1] - 2019-04-20 ### Added - Extended `SQLStatement::SQLCreateTable` to support Hive's EXTERNAL TABLES (`CREATE EXTERNAL TABLE .. STORED AS .. LOCATION '..'`) - thanks @zhzy0077! (#46) - Parse `SELECT DISTINCT` to `SQLSelect::distinct` (#49) ## [0.3.0] - 2019-04-03 ### Changed This release includes major changes to the AST structs to add a number of features, as described in #37 and #43. In particular: - `ASTNode` variants that represent statements were extracted from `ASTNode` into a separate `SQLStatement` enum; - `Parser::parse_sql` now returns a `Vec` of parsed statements. - `ASTNode` now represents an expression (renamed to `Expr` in 0.4.0) - The query representation (formerly `ASTNode::SQLSelect`) became more complicated to support: - `WITH` and `UNION`/`EXCEPT`/`INTERSECT` (via `SQLQuery`, `Cte`, and `SQLSetExpr`), - aliases and qualified wildcards in `SELECT` (via `SQLSelectItem`), - and aliases in `FROM`/`JOIN` (via `TableFactor`). - A new `SQLObjectName` struct is used instead of `String` or `ASTNode::SQLCompoundIdentifier` - for objects like tables, custom types, etc. - Added support for "delimited identifiers" and made keywords context-specific (thus accepting them as valid identifiers in most contexts) - **this caused a regression in parsing `SELECT .. FROM .. LIMIT ..` (#67), fixed in 0.4.0** ### Added Other than the changes listed above, some less intrusive additions include: - Support `CREATE [MATERIALIZED] VIEW` statement - Support `IN`, `BETWEEN`, unary +/- in epressions - Support `CHAR` data type and `NUMERIC` not followed by `(p,s)`. - Support national string literals (`N'...'`) ## [0.2.4] - 2019-03-08 Same as 0.2.2. ## [0.2.3] - 2019-03-08 [YANKED] ## [0.2.2] - 2019-03-08 ### Changed - Removed `Value::String`, `Value::DoubleQuotedString`, and `Token::String`, making - `'...'` parse as a string literal (`Value::SingleQuotedString`), and - `"..."` fail to parse until version 0.3.0 (#36) ## [0.2.1] - 2019-01-13 We don't have a changelog for the changes made in 2018, but thanks to @crw5996, @cswinter, @fredrikroos, @ivanceras, @nickolay, @virattara for their contributions in the early stages of the project! ## [0.1.0] - 2018-09-03 Initial release apache-datafusion-sqlparser-rs-0.62.0/changelog/0.52.0.md000066400000000000000000000157341517524037000226200ustar00rootroot00000000000000 # sqlparser-rs 0.52.0 Changelog This release consists of 45 commits from 20 contributors. See credits at the end of this changelog for more information. **Implemented enhancements:** - feat: support explain options [#1426](https://github.com/apache/datafusion-sqlparser-rs/pull/1426) (kysshsy) - feat: adding Display implementation to DELETE and INSERT [#1427](https://github.com/apache/datafusion-sqlparser-rs/pull/1427) (seve-martinez) **Fixed bugs:** - fix: `maybe_parse` preventing parser from erroring on recursion limit [#1464](https://github.com/apache/datafusion-sqlparser-rs/pull/1464) (tomershaniii) **Other:** - Fix parsing of negative values [#1419](https://github.com/apache/datafusion-sqlparser-rs/pull/1419) (agscpp) - Allow to use ON CLUSTER cluster_name in TRUNCATE syntax [#1428](https://github.com/apache/datafusion-sqlparser-rs/pull/1428) (git-hulk) - chore: remove redundant punctuation [#1434](https://github.com/apache/datafusion-sqlparser-rs/pull/1434) (Fischer0522) - MS SQL Server: add support for IDENTITY column option [#1432](https://github.com/apache/datafusion-sqlparser-rs/pull/1432) (7phs) - Update to ASF header / add when missing [#1437](https://github.com/apache/datafusion-sqlparser-rs/pull/1437) (alamb) - Some small optimizations [#1424](https://github.com/apache/datafusion-sqlparser-rs/pull/1424) (exrok) - Fix `codestyle` CI check [#1438](https://github.com/apache/datafusion-sqlparser-rs/pull/1438) (alamb) - Implements CREATE POLICY syntax for PostgreSQL [#1440](https://github.com/apache/datafusion-sqlparser-rs/pull/1440) (git-hulk) - make `parse_expr_with_alias` public [#1444](https://github.com/apache/datafusion-sqlparser-rs/pull/1444) (Eason0729) - Implements DROP POLICY syntax for PostgreSQL [#1445](https://github.com/apache/datafusion-sqlparser-rs/pull/1445) (git-hulk) - Support `DROP DATABASE` [#1443](https://github.com/apache/datafusion-sqlparser-rs/pull/1443) (linhr) - Implements ALTER POLICY syntax for PostgreSQL [#1446](https://github.com/apache/datafusion-sqlparser-rs/pull/1446) (git-hulk) - Add a note discouraging new use of `dialect_of` macro [#1448](https://github.com/apache/datafusion-sqlparser-rs/pull/1448) (alamb) - Expand handling of `LIMIT 1, 2` handling to include sqlite [#1447](https://github.com/apache/datafusion-sqlparser-rs/pull/1447) (joshuawarner32) - Fix always uses CommentDef::WithoutEq while parsing the inline comment [#1453](https://github.com/apache/datafusion-sqlparser-rs/pull/1453) (git-hulk) - Add support for the LIKE ANY and ILIKE ANY pattern-matching condition [#1456](https://github.com/apache/datafusion-sqlparser-rs/pull/1456) (yoavcloud) - added ability to parse extension to parse_comment inside postgres dialect [#1451](https://github.com/apache/datafusion-sqlparser-rs/pull/1451) (MaxwellKnight) - Snowflake: support of views column comment [#1441](https://github.com/apache/datafusion-sqlparser-rs/pull/1441) (7phs) - Add SQLite "ON CONFLICT" column option in CREATE TABLE statements [#1442](https://github.com/apache/datafusion-sqlparser-rs/pull/1442) (nucccc) - Add support for ASC and DESC in CREATE TABLE column constraints for SQLite. [#1462](https://github.com/apache/datafusion-sqlparser-rs/pull/1462) (caldwell) - Add support of `EXPLAIN QUERY PLAN` syntax for SQLite dialect [#1458](https://github.com/apache/datafusion-sqlparser-rs/pull/1458) (git-hulk) - Add "DROP TYPE" support. [#1461](https://github.com/apache/datafusion-sqlparser-rs/pull/1461) (caldwell) - chore: Add asf.yaml [#1463](https://github.com/apache/datafusion-sqlparser-rs/pull/1463) (Xuanwo) - Add support for quantified comparison predicates (ALL/ANY/SOME) [#1459](https://github.com/apache/datafusion-sqlparser-rs/pull/1459) (yoavcloud) - MySQL dialect: Add support for hash comments [#1466](https://github.com/apache/datafusion-sqlparser-rs/pull/1466) (hansott) - Fix #1469 (SET ROLE regression) [#1474](https://github.com/apache/datafusion-sqlparser-rs/pull/1474) (lovasoa) - Add support for parsing MsSql alias with equals [#1467](https://github.com/apache/datafusion-sqlparser-rs/pull/1467) (yoavcloud) - Snowflake: support for extended column options in `CREATE TABLE` [#1454](https://github.com/apache/datafusion-sqlparser-rs/pull/1454) (7phs) - MsSQL TRY_CONVERT [#1477](https://github.com/apache/datafusion-sqlparser-rs/pull/1477) (yoavcloud) - Add PostgreSQL specfic "CREATE TYPE t AS ENUM (...)" support. [#1460](https://github.com/apache/datafusion-sqlparser-rs/pull/1460) (caldwell) - Fix build [#1483](https://github.com/apache/datafusion-sqlparser-rs/pull/1483) (yoavcloud) - Fix complex blocks warning when running clippy [#1488](https://github.com/apache/datafusion-sqlparser-rs/pull/1488) (git-hulk) - Add support for SHOW DATABASES/SCHEMAS/TABLES/VIEWS in Hive [#1487](https://github.com/apache/datafusion-sqlparser-rs/pull/1487) (yoavcloud) - Fix typo in `Dialect::supports_eq_alias_assigment` [#1478](https://github.com/apache/datafusion-sqlparser-rs/pull/1478) (alamb) - Add support for PostgreSQL `LISTEN/NOTIFY` syntax [#1485](https://github.com/apache/datafusion-sqlparser-rs/pull/1485) (wugeer) - Add support for TOP before ALL/DISTINCT [#1495](https://github.com/apache/datafusion-sqlparser-rs/pull/1495) (yoavcloud) - add support for `FOR ORDINALITY` and `NESTED` in JSON_TABLE [#1493](https://github.com/apache/datafusion-sqlparser-rs/pull/1493) (lovasoa) - Add Apache License to additional files [#1502](https://github.com/apache/datafusion-sqlparser-rs/pull/1502) (alamb) - Move CHANGELOG content [#1503](https://github.com/apache/datafusion-sqlparser-rs/pull/1503) (alamb) - improve support for T-SQL EXECUTE statements [#1490](https://github.com/apache/datafusion-sqlparser-rs/pull/1490) (lovasoa) ## Credits Thank you to everyone who contributed to this release. Here is a breakdown of commits (PRs merged) per contributor. ``` 8 Andrew Lamb 7 Yoav Cohen 7 hulk 3 Aleksei Piianin 3 David Caldwell 3 Ophir LOJKINE 1 Agaev Guseyn 1 Eason 1 Fischer 1 Hans Ott 1 Heran Lin 1 Joshua Warner 1 Maxwell Knight 1 Seve Martinez 1 Siyuan Huang 1 Thomas Dagenais 1 Xuanwo 1 nucccc 1 tomershaniii 1 wugeer ``` Thank you also to everyone who contributed in other ways such as filing issues, reviewing PRs, and providing feedback on this release. apache-datafusion-sqlparser-rs-0.62.0/changelog/0.53.0.md000066400000000000000000000162221517524037000226120ustar00rootroot00000000000000 # 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. apache-datafusion-sqlparser-rs-0.62.0/changelog/0.54.0.md000066400000000000000000000213211517524037000226070ustar00rootroot00000000000000 # 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. apache-datafusion-sqlparser-rs-0.62.0/changelog/0.55.0.md000066400000000000000000000240511517524037000226130ustar00rootroot00000000000000 # 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); + pub struct ObjectName(pub Vec) ``` ### 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 [#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. apache-datafusion-sqlparser-rs-0.62.0/changelog/0.56.0.md000066400000000000000000000172341517524037000226210ustar00rootroot00000000000000 # 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 , ` 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. apache-datafusion-sqlparser-rs-0.62.0/changelog/0.57.0.md000066400000000000000000000147441517524037000226250ustar00rootroot00000000000000 # 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 ( )` [#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. apache-datafusion-sqlparser-rs-0.62.0/changelog/0.58.0.md000066400000000000000000000170271517524037000226230ustar00rootroot00000000000000 # sqlparser-rs 0.58.0 Changelog This release consists of 47 commits from 18 contributors. See credits at the end of this changelog for more information. **Fixed bugs:** - fix: parse snowflake fetch clause [#1894](https://github.com/apache/datafusion-sqlparser-rs/pull/1894) (Vedin) **Documentation updates:** - docs: Update rust badge [#1943](https://github.com/apache/datafusion-sqlparser-rs/pull/1943) (Olexandr88) **Other:** - Add license header check to CI [#1888](https://github.com/apache/datafusion-sqlparser-rs/pull/1888) (alamb) - Add support of parsing struct field's options in BigQuery [#1890](https://github.com/apache/datafusion-sqlparser-rs/pull/1890) (git-hulk) - Fix parsing error when having fields after nested struct in BigQuery [#1897](https://github.com/apache/datafusion-sqlparser-rs/pull/1897) (git-hulk) - Extend exception handling [#1884](https://github.com/apache/datafusion-sqlparser-rs/pull/1884) (bombsimon) - Postgres: Add support for text search types [#1889](https://github.com/apache/datafusion-sqlparser-rs/pull/1889) (MohamedAbdeen21) - Fix `limit` in subqueries [#1899](https://github.com/apache/datafusion-sqlparser-rs/pull/1899) (Dimchikkk) - Use `IndexColumn` in all index definitions [#1900](https://github.com/apache/datafusion-sqlparser-rs/pull/1900) (mvzink) - Support procedure argmode [#1901](https://github.com/apache/datafusion-sqlparser-rs/pull/1901) (ZacJW) - Fix `impl Ord for Ident` [#1893](https://github.com/apache/datafusion-sqlparser-rs/pull/1893) (eliaperantoni) - Snowflake: support multiple column options in `CREATE VIEW` [#1891](https://github.com/apache/datafusion-sqlparser-rs/pull/1891) (eliaperantoni) - Add support for `LANGUAGE` clause in `CREATE PROCEDURE` [#1903](https://github.com/apache/datafusion-sqlparser-rs/pull/1903) (ZacJW) - Fix clippy lints on 1.88.0 [#1910](https://github.com/apache/datafusion-sqlparser-rs/pull/1910) (iffyio) - Snowflake: Add support for future grants [#1906](https://github.com/apache/datafusion-sqlparser-rs/pull/1906) (yoavcloud) - Support for Map values in ClickHouse settings [#1896](https://github.com/apache/datafusion-sqlparser-rs/pull/1896) (solontsev) - Fix join precedence for non-snowflake queries [#1905](https://github.com/apache/datafusion-sqlparser-rs/pull/1905) (Dimchikkk) - Support remaining pipe operators [#1879](https://github.com/apache/datafusion-sqlparser-rs/pull/1879) (simonvandel) - Make `GenericDialect` support from-first syntax [#1911](https://github.com/apache/datafusion-sqlparser-rs/pull/1911) (simonvandel) - Redshift utf8 idents [#1915](https://github.com/apache/datafusion-sqlparser-rs/pull/1915) (yoavcloud) - DuckDB: Add support for multiple `TRIM` arguments [#1916](https://github.com/apache/datafusion-sqlparser-rs/pull/1916) (ryanschneider) - Redshift alter column type no set [#1912](https://github.com/apache/datafusion-sqlparser-rs/pull/1912) (yoavcloud) - Postgres: support `ADD CONSTRAINT NOT VALID` and `VALIDATE CONSTRAINT` [#1908](https://github.com/apache/datafusion-sqlparser-rs/pull/1908) (achristmascarl) - Add support for MySQL MEMBER OF [#1917](https://github.com/apache/datafusion-sqlparser-rs/pull/1917) (yoavcloud) - Add span for `Expr::TypedString` [#1919](https://github.com/apache/datafusion-sqlparser-rs/pull/1919) (feral-dot-io) - Support for Postgres `CREATE SERVER` [#1914](https://github.com/apache/datafusion-sqlparser-rs/pull/1914) (solontsev) - Change tag and policy names to `ObjectName` [#1892](https://github.com/apache/datafusion-sqlparser-rs/pull/1892) (eliaperantoni) - Add support for NULL escape char in pattern match searches [#1913](https://github.com/apache/datafusion-sqlparser-rs/pull/1913) (yoavcloud) - Add support for dropping multiple columns in Snowflake [#1918](https://github.com/apache/datafusion-sqlparser-rs/pull/1918) (yoavcloud) - Align Snowflake dialect to new test of reserved keywords [#1924](https://github.com/apache/datafusion-sqlparser-rs/pull/1924) (yoavcloud) - Make `GenericDialect` support trailing commas in projections [#1921](https://github.com/apache/datafusion-sqlparser-rs/pull/1921) (simonvandel) - Add support for several Snowflake grant statements [#1922](https://github.com/apache/datafusion-sqlparser-rs/pull/1922) (yoavcloud) - Clickhouse: support empty parenthesized options [#1925](https://github.com/apache/datafusion-sqlparser-rs/pull/1925) (solontsev) - Add Snowflake `COPY/REVOKE CURRENT GRANTS` option [#1926](https://github.com/apache/datafusion-sqlparser-rs/pull/1926) (yoavcloud) - Add support for Snowflake identifier function [#1929](https://github.com/apache/datafusion-sqlparser-rs/pull/1929) (yoavcloud) - Add support for granting privileges to procedures and functions in Snowflake [#1930](https://github.com/apache/datafusion-sqlparser-rs/pull/1930) (yoavcloud) - Add support for `+` char in Snowflake stage names [#1935](https://github.com/apache/datafusion-sqlparser-rs/pull/1935) (yoavcloud) - Snowflake Reserved SQL Keywords as Implicit Table Alias [#1934](https://github.com/apache/datafusion-sqlparser-rs/pull/1934) (yoavcloud) - Add support for Redshift `SELECT * EXCLUDE` [#1936](https://github.com/apache/datafusion-sqlparser-rs/pull/1936) (yoavcloud) - Support optional semicolon between statements [#1937](https://github.com/apache/datafusion-sqlparser-rs/pull/1937) (yoavcloud) - Snowflake: support trailing options in `CREATE TABLE` [#1931](https://github.com/apache/datafusion-sqlparser-rs/pull/1931) (yoavcloud) - MSSQL: Add support for EXEC output and default keywords [#1940](https://github.com/apache/datafusion-sqlparser-rs/pull/1940) (yoavcloud) - Add identifier unicode support in Mysql, Postgres and Redshift [#1933](https://github.com/apache/datafusion-sqlparser-rs/pull/1933) (etgarperets) - Add identifier start unicode support for Postegres, MySql and Redshift [#1944](https://github.com/apache/datafusion-sqlparser-rs/pull/1944) (etgarperets) - Fix for Postgres regex and like binary operators [#1928](https://github.com/apache/datafusion-sqlparser-rs/pull/1928) (solontsev) - Snowflake: Improve accuracy of lookahead in implicit LIMIT alias [#1941](https://github.com/apache/datafusion-sqlparser-rs/pull/1941) (yoavcloud) - Add support for `DROP USER` statement [#1951](https://github.com/apache/datafusion-sqlparser-rs/pull/1951) (yoavcloud) ## Credits Thank you to everyone who contributed to this release. Here is a breakdown of commits (PRs merged) per contributor. ``` 19 Yoav Cohen 4 Sergey Olontsev 3 Elia Perantoni 3 Simon Vandel Sillesen 2 Dima 2 ZacJW 2 etgarperets 2 hulk 1 Andrew Lamb 1 Denys Tsomenko 1 Ifeanyi Ubah 1 Michael Victor Zink 1 Mohamed Abdeen 1 Olexandr88 1 Ryan Schneider 1 Simon Sawert 1 carl 1 feral-dot-io ``` Thank you also to everyone who contributed in other ways such as filing issues, reviewing PRs, and providing feedback on this release. apache-datafusion-sqlparser-rs-0.62.0/changelog/0.59.0.md000066400000000000000000000222651517524037000226240ustar00rootroot00000000000000 # sqlparser-rs 0.59.0 Changelog This release consists of 59 commits from 22 contributors. See credits at the end of this changelog for more information. **Implemented enhancements:** - feat: support export data for bigquery [#1976](https://github.com/apache/datafusion-sqlparser-rs/pull/1976) (chenkovsky) - feat: support multi value columns and aliases in unpivot [#1969](https://github.com/apache/datafusion-sqlparser-rs/pull/1969) (chenkovsky) - feat: Include end token in `ALTER TABLE` statement [#1999](https://github.com/apache/datafusion-sqlparser-rs/pull/1999) (IndexSeek) - feat: support multiple value for pivot [#1970](https://github.com/apache/datafusion-sqlparser-rs/pull/1970) (chenkovsky) - feat: Add `ALTER SCHEMA` support [#1980](https://github.com/apache/datafusion-sqlparser-rs/pull/1980) (chenkovsky) - feat: MERGE statements: add RETURNING and OUTPUT without INTO [#2011](https://github.com/apache/datafusion-sqlparser-rs/pull/2011) (lovasoa) - feat: support postgres alter schema [#2038](https://github.com/apache/datafusion-sqlparser-rs/pull/2038) (chenkovsky) **Fixed bugs:** - fix: begin statement for bigquery [#1975](https://github.com/apache/datafusion-sqlparser-rs/pull/1975) (chenkovsky) - fix: update DuckDB and ClickHouse documentation links [#1978](https://github.com/apache/datafusion-sqlparser-rs/pull/1978) (IndexSeek) **Other:** - MySQL: Support `EXPLAIN ANALYZE` format variants [#1945](https://github.com/apache/datafusion-sqlparser-rs/pull/1945) (yoavcloud) - Add support for `NOT NULL` and `NOTNULL` expressions [#1927](https://github.com/apache/datafusion-sqlparser-rs/pull/1927) (ryanschneider) - Snowflake: Support `CLONE` option in `CREATE DATABASE/SCHEMA` statements [#1958](https://github.com/apache/datafusion-sqlparser-rs/pull/1958) (yoavcloud) - Add support for `GRANT DROP` statement [#1959](https://github.com/apache/datafusion-sqlparser-rs/pull/1959) (yoavcloud) - Snowflake: Add support for `CREATE USER` [#1950](https://github.com/apache/datafusion-sqlparser-rs/pull/1950) (yoavcloud) - Postgres: Support parenthesized `SET` options for `ALTER TABLE` [#1947](https://github.com/apache/datafusion-sqlparser-rs/pull/1947) (achristmascarl) - Snowflake: Support IDENTIFIER for GRANT ROLE [#1957](https://github.com/apache/datafusion-sqlparser-rs/pull/1957) (yoavcloud) - Snowflake: Numeric prefix for stage name part [#1966](https://github.com/apache/datafusion-sqlparser-rs/pull/1966) (yoavcloud) - Snowflake: Support `GRANT CREATE SCHEMA` `GRANT .. ON ALL FUNCTIONS IN SCHEMA` [#1964](https://github.com/apache/datafusion-sqlparser-rs/pull/1964) (yoavcloud) - Snowflake: DROP STREAM [#1973](https://github.com/apache/datafusion-sqlparser-rs/pull/1973) (yoavcloud) - Add ODBC escape syntax support for time expressions [#1953](https://github.com/apache/datafusion-sqlparser-rs/pull/1953) (etgarperets) - Add support for `SHOW CHARSET` [#1974](https://github.com/apache/datafusion-sqlparser-rs/pull/1974) (etgarperets) - Snowflake: Support `CREATE VIEW myview IF NOT EXISTS` [#1961](https://github.com/apache/datafusion-sqlparser-rs/pull/1961) (etgarperets) - Update criterion requirement from 0.6 to 0.7 in /sqlparser_bench [#1981](https://github.com/apache/datafusion-sqlparser-rs/pull/1981) (dependabot[bot]) - Snowflake: Improve support for reserved keywords for table factor [#1942](https://github.com/apache/datafusion-sqlparser-rs/pull/1942) (yoavcloud) - MySQL: Allow optional `SIGNED` suffix on integer data types [#1985](https://github.com/apache/datafusion-sqlparser-rs/pull/1985) (mvzink) - Fix placeholder spans [#1979](https://github.com/apache/datafusion-sqlparser-rs/pull/1979) (xitep) - Snowflake create database [#1939](https://github.com/apache/datafusion-sqlparser-rs/pull/1939) (osipovartem) - Postgres: Support `INTERVAL` data type options [#1984](https://github.com/apache/datafusion-sqlparser-rs/pull/1984) (mvzink) - MySQL: Support comma-separated `CREATE TABLE` options [#1989](https://github.com/apache/datafusion-sqlparser-rs/pull/1989) (mvzink) - MySQL: Support `ALTER TABLE RENAME AS` [#1965](https://github.com/apache/datafusion-sqlparser-rs/pull/1965) (altmannmarcelo) - Improve MySQL `CREATE TRIGGER` parsing [#1998](https://github.com/apache/datafusion-sqlparser-rs/pull/1998) (mvzink) - Snowflake - support table function in table factor (regression) [#1996](https://github.com/apache/datafusion-sqlparser-rs/pull/1996) (tomershaniii) - Improve MySQL option parsing in index definitions [#1997](https://github.com/apache/datafusion-sqlparser-rs/pull/1997) (mvzink) - Add support for `UPDATE ... LIMIT ...` [#1991](https://github.com/apache/datafusion-sqlparser-rs/pull/1991) (xtuc) - Postgres: enhance NUMERIC/DECIMAL parsing to support negative scale [#1990](https://github.com/apache/datafusion-sqlparser-rs/pull/1990) (IndexSeek) - Fix column definition `COLLATE` parsing [#1986](https://github.com/apache/datafusion-sqlparser-rs/pull/1986) (mvzink) - Redshift: CREATE TABLE ... (LIKE ..) [#1967](https://github.com/apache/datafusion-sqlparser-rs/pull/1967) (yoavcloud) - Add drop behavior to `DROP PRIMARY/FOREIGN KEY` [#2002](https://github.com/apache/datafusion-sqlparser-rs/pull/2002) (yoavcloud) - Redshift: Add support for IAM_ROLE and IGNOREHEADER COPY options [#1968](https://github.com/apache/datafusion-sqlparser-rs/pull/1968) (yoavcloud) - Snowflake: Add support for `CREATE DYNAMIC TABLE` [#1960](https://github.com/apache/datafusion-sqlparser-rs/pull/1960) (yoavcloud) - Add support for VACUUM in Redshift [#2005](https://github.com/apache/datafusion-sqlparser-rs/pull/2005) (yoavcloud) - Add support for `SEMANTIC_VIEW` table factor [#2009](https://github.com/apache/datafusion-sqlparser-rs/pull/2009) (bombsimon) - Redshift: Add more copy options [#2008](https://github.com/apache/datafusion-sqlparser-rs/pull/2008) (yoavcloud) - `GenericDialect`: Support pipe operator [#2012](https://github.com/apache/datafusion-sqlparser-rs/pull/2012) (simonvandel) - Add SECURE keyword for views in Snowflake [#2004](https://github.com/apache/datafusion-sqlparser-rs/pull/2004) (Vedin) - Add support for PostgreSQL JSON function 'RETURNING' clauses [#2001](https://github.com/apache/datafusion-sqlparser-rs/pull/2001) (adamchainz) - Snowflake: Minus char in stage name [#2014](https://github.com/apache/datafusion-sqlparser-rs/pull/2014) (yoavcloud) - Support wildcard metrics for `SEMANTIC_VIEW` [#2016](https://github.com/apache/datafusion-sqlparser-rs/pull/2016) (bombsimon) - Allow wilrdacrd for all `SEMANTIC_VIEW` types [#2017](https://github.com/apache/datafusion-sqlparser-rs/pull/2017) (bombsimon) - Redshift: UNLOAD [#2013](https://github.com/apache/datafusion-sqlparser-rs/pull/2013) (yoavcloud) - Add support for string literal concatenation [#2003](https://github.com/apache/datafusion-sqlparser-rs/pull/2003) (etgarperets) - Enable merge queue in sqlparser-rs [#2007](https://github.com/apache/datafusion-sqlparser-rs/pull/2007) (blaginin) - Merge Queue Test [#2019](https://github.com/apache/datafusion-sqlparser-rs/pull/2019) (blaginin) - Added derive trait `Copy` to `OrderByOptions` struct [#2021](https://github.com/apache/datafusion-sqlparser-rs/pull/2021) (LucaCappelletti94) - Moved `CreateTrigger` and `DropTrigger` out of `Statement` enum [#2026](https://github.com/apache/datafusion-sqlparser-rs/pull/2026) (LucaCappelletti94) - MySQL: Support `CROSS JOIN` constraint [#2025](https://github.com/apache/datafusion-sqlparser-rs/pull/2025) (rs-sac) - Implemented the `From` method for all clear variants in Statement [#2028](https://github.com/apache/datafusion-sqlparser-rs/pull/2028) (LucaCappelletti94) - DuckDB: Allow quoted date parts in EXTRACT [#2030](https://github.com/apache/datafusion-sqlparser-rs/pull/2030) (ryanschneider) - MySQL: Add support for unsigned numeric types [#2031](https://github.com/apache/datafusion-sqlparser-rs/pull/2031) (MohamedAbdeen21) ## Credits Thank you to everyone who contributed to this release. Here is a breakdown of commits (PRs merged) per contributor. ``` 17 Yoav Cohen 6 Chen Chongchen 6 Michael Victor Zink 4 etgarperets 3 Luca Cappelletti 3 Simon Sawert 3 Tyler White 2 Dmitrii Blaginin 2 Ryan Schneider 1 Adam Johnson 1 Artem Osipov 1 Denys Tsomenko 1 Marcelo Altmann 1 Mohamed Abdeen 1 Ophir LOJKINE 1 Sidney Cammeresi 1 Simon Vandel Sillesen 1 Sven Sauleau 1 carl 1 dependabot[bot] 1 tomershaniii 1 xitep ``` Thank you also to everyone who contributed in other ways such as filing issues, reviewing PRs, and providing feedback on this release. apache-datafusion-sqlparser-rs-0.62.0/changelog/0.60.0.md000066400000000000000000000151171517524037000226120ustar00rootroot00000000000000 # sqlparser-rs 0.60.0 Changelog This release consists of 37 commits from 20 contributors. See credits at the end of this changelog for more information. **Implemented enhancements:** - feat: Add RESET to the base dialect #2078 [#2079](https://github.com/apache/datafusion-sqlparser-rs/pull/2079) (watford-ep) - feat: Add support for SET SESSION AUTHORIZATION #2086 [#2087](https://github.com/apache/datafusion-sqlparser-rs/pull/2087) (watford-ep) **Fixed bugs:** - fix: parse error on unnamed arg with default syntax [#2091](https://github.com/apache/datafusion-sqlparser-rs/pull/2091) (r1b) **Other:** - Add support for INVISIBLE columns in MySQL [#2033](https://github.com/apache/datafusion-sqlparser-rs/pull/2033) (altmannmarcelo) - Link to actual change logs in CHANGELOG.md [#2040](https://github.com/apache/datafusion-sqlparser-rs/pull/2040) (lovasoa) - Snowflake: ALTER USER and KeyValueOptions Refactoring [#2035](https://github.com/apache/datafusion-sqlparser-rs/pull/2035) (yoavcloud) - Correctly tokenize nested comments in Databricks, ClickHouse, and ANSI [#2044](https://github.com/apache/datafusion-sqlparser-rs/pull/2044) (jmhain) - MySQL: `CREATE INDEX`: allow `USING` clause before `ON` [#2029](https://github.com/apache/datafusion-sqlparser-rs/pull/2029) (MohamedAbdeen21) - [databricks] update dialect to support grouping by with modifier [#2047](https://github.com/apache/datafusion-sqlparser-rs/pull/2047) (n-young) - Moved constraint variant outside of `TableConstraint` enum [#2054](https://github.com/apache/datafusion-sqlparser-rs/pull/2054) (LucaCappelletti94) - Add support for procedure parameter default values [#2041](https://github.com/apache/datafusion-sqlparser-rs/pull/2041) (aharpervc) - Support updating PRs using github UI [#2052](https://github.com/apache/datafusion-sqlparser-rs/pull/2052) (blaginin) - Increase version of sqlparser_derive from 0.3.0 to 0.4.0 [#2060](https://github.com/apache/datafusion-sqlparser-rs/pull/2060) (jjbayer) - Moving several struct variants out of `Statement` enum to allow for trait impls for specific sub-variants [#2057](https://github.com/apache/datafusion-sqlparser-rs/pull/2057) (LucaCappelletti94) - Added support for SQLite triggers [#2037](https://github.com/apache/datafusion-sqlparser-rs/pull/2037) (LucaCappelletti94) - Added support for MATCH syntax and unified column option ForeignKey [#2062](https://github.com/apache/datafusion-sqlparser-rs/pull/2062) (LucaCappelletti94) - chore: add stack overflow warning for Visitor and VisitorMut [#2068](https://github.com/apache/datafusion-sqlparser-rs/pull/2068) (niebayes) - Reused `CheckConstraint` in `ColumnOption` [#2063](https://github.com/apache/datafusion-sqlparser-rs/pull/2063) (LucaCappelletti94) - Refactored `ColumnOption::Unique` to reuse `UniqueConstraint` and `PrimaryKeyConstraint` [#2064](https://github.com/apache/datafusion-sqlparser-rs/pull/2064) (LucaCappelletti94) - Redshift: more copy options [#2072](https://github.com/apache/datafusion-sqlparser-rs/pull/2072) (yoavcloud) - SQLite: make period optional for CREATE TRIGGER [#2071](https://github.com/apache/datafusion-sqlparser-rs/pull/2071) (takluyver) - Added TIMESTAMP_NTZ type support with precision to Snowflake dialect [#2080](https://github.com/apache/datafusion-sqlparser-rs/pull/2080) (romanoff) - Make `BitwiseNot` ("~") available for all dialects, not just PostgreSQL [#2081](https://github.com/apache/datafusion-sqlparser-rs/pull/2081) (alexander-beedie) - Add snowflake dynamic table parsing [#2083](https://github.com/apache/datafusion-sqlparser-rs/pull/2083) (romanoff) - Add support for `INSERT INTO VALUE` [#2085](https://github.com/apache/datafusion-sqlparser-rs/pull/2085) (etgarperets) - Complete PostgreSQL `CREATE TYPE` Support [#2094](https://github.com/apache/datafusion-sqlparser-rs/pull/2094) (LucaCappelletti94) - Include DML keyword in statement span [#2090](https://github.com/apache/datafusion-sqlparser-rs/pull/2090) (xitep) - Add PostgreSQL Operator DDL Support [#2096](https://github.com/apache/datafusion-sqlparser-rs/pull/2096) (LucaCappelletti94) - impl `Spanned` for MERGE statements [#2100](https://github.com/apache/datafusion-sqlparser-rs/pull/2100) (xitep) - Preserve optional `AS` keyword in aliases [#2103](https://github.com/apache/datafusion-sqlparser-rs/pull/2103) (xitep) - Added support for `DROP OPERATOR` syntax [#2102](https://github.com/apache/datafusion-sqlparser-rs/pull/2102) (LucaCappelletti94) - Only set `hive_formats` on `CreateTable` if formats are present [#2105](https://github.com/apache/datafusion-sqlparser-rs/pull/2105) (mvzink) - Support PostgreSQL C Functions with Multiple AS Parameters [#2095](https://github.com/apache/datafusion-sqlparser-rs/pull/2095) (LucaCappelletti94) - Added support for `DROP OPERATOR FAMILY` [#2106](https://github.com/apache/datafusion-sqlparser-rs/pull/2106) (LucaCappelletti94) - Update criterion requirement from 0.7 to 0.8 in /sqlparser_bench [#2111](https://github.com/apache/datafusion-sqlparser-rs/pull/2111) (dependabot[bot]) - Added support for `DROP OPERATOR CLASS` syntax [#2109](https://github.com/apache/datafusion-sqlparser-rs/pull/2109) (LucaCappelletti94) - Introduce Oracle dialect [#2113](https://github.com/apache/datafusion-sqlparser-rs/pull/2113) (xitep) ## Credits Thank you to everyone who contributed to this release. Here is a breakdown of commits (PRs merged) per contributor. ``` 12 Luca Cappelletti 4 xitep 2 Andriy Romanov 2 Christopher Watford 2 Yoav Cohen 1 Alexander Beedie 1 Andrew Harper 1 Dmitrii Blaginin 1 Joey Hain 1 Joris Bayer 1 Marcelo Altmann 1 Michael Victor Zink 1 Mohamed Abdeen 1 Ophir LOJKINE 1 Thomas Kluyver 1 dependabot[bot] 1 etgarperets 1 nick young 1 niebayes 1 r1b ``` Thank you also to everyone who contributed in other ways such as filing issues, reviewing PRs, and providing feedback on this release. apache-datafusion-sqlparser-rs-0.62.0/changelog/0.61.0.md000066400000000000000000000242611517524037000226130ustar00rootroot00000000000000 # sqlparser-rs 0.61.0 Changelog This release consists of 66 commits from 22 contributors. See credits at the end of this changelog for more information. **Performance related:** - perf: remove unnecessary string clone in maybe_concat_string_literal [#2173](https://github.com/apache/datafusion-sqlparser-rs/pull/2173) (andygrove) - perf: optimize `make_word()` to avoid unnecessary allocations [#2176](https://github.com/apache/datafusion-sqlparser-rs/pull/2176) (andygrove) **Fixed bugs:** - fix: Set the current folder as a "primary" for the `find` command [#2120](https://github.com/apache/datafusion-sqlparser-rs/pull/2120) (martin-g) - fix: qualified column names with SQL keywords parse as identifiers [#2157](https://github.com/apache/datafusion-sqlparser-rs/pull/2157) (bombsimon) **Other:** - Fixing location for extrenal tables [#2108](https://github.com/apache/datafusion-sqlparser-rs/pull/2108) (romanoff) - Added support for `ALTER OPERATOR` syntax [#2114](https://github.com/apache/datafusion-sqlparser-rs/pull/2114) (LucaCappelletti94) - Oracle: Support for MERGE predicates [#2101](https://github.com/apache/datafusion-sqlparser-rs/pull/2101) (xitep) - [Oracle] Lower StringConcat precedence [#2115](https://github.com/apache/datafusion-sqlparser-rs/pull/2115) (xitep) - Added alter external table support for snowflake [#2122](https://github.com/apache/datafusion-sqlparser-rs/pull/2122) (romanoff) - MSSQL: Add support for parenthesized stored procedure name in EXEC [#2126](https://github.com/apache/datafusion-sqlparser-rs/pull/2126) (yoavcloud) - MSSQL: Parse IF/ELSE without semicolon delimiters [#2128](https://github.com/apache/datafusion-sqlparser-rs/pull/2128) (yoavcloud) - Extract source comments [#2107](https://github.com/apache/datafusion-sqlparser-rs/pull/2107) (xitep) - PostgreSQL: Support schema-qualified operator classes in CREATE INDEX [#2131](https://github.com/apache/datafusion-sqlparser-rs/pull/2131) (dddenis) - Oracle: Support for quote delimited strings [#2130](https://github.com/apache/datafusion-sqlparser-rs/pull/2130) (xitep) - Added support for `ALTER OPERATOR FAMILY` syntax [#2125](https://github.com/apache/datafusion-sqlparser-rs/pull/2125) (LucaCappelletti94) - PostgreSQL Tokenization: Fix unexpected characters after question mark being silently ignored [#2129](https://github.com/apache/datafusion-sqlparser-rs/pull/2129) (jnlt3) - Support parsing parenthesized wildcard `(*)` [#2123](https://github.com/apache/datafusion-sqlparser-rs/pull/2123) (romanoff) - Make benchmark statement valid [#2139](https://github.com/apache/datafusion-sqlparser-rs/pull/2139) (xitep) - Fix parse_identifiers not taking semicolons into account [#2137](https://github.com/apache/datafusion-sqlparser-rs/pull/2137) (jnlt3) - Add PostgreSQL PARTITION OF syntax support [#2127](https://github.com/apache/datafusion-sqlparser-rs/pull/2127) (fmguerreiro) - Databricks: Support Timetravel With "TIMESTAMP AS OF" [#2134](https://github.com/apache/datafusion-sqlparser-rs/pull/2134) (JamesVorder) - MySQL: Parse bitwise shift left/right operators [#2152](https://github.com/apache/datafusion-sqlparser-rs/pull/2152) (mvzink) - Redshift: Add support for optional JSON format in copy option [#2141](https://github.com/apache/datafusion-sqlparser-rs/pull/2141) (yoavcloud) - MySQL: Add missing support for TREE explain format [#2145](https://github.com/apache/datafusion-sqlparser-rs/pull/2145) (yoavcloud) - MySQL: Add support for && as boolean AND [#2144](https://github.com/apache/datafusion-sqlparser-rs/pull/2144) (yoavcloud) - PostgreSQL: ALTER USER password option [#2142](https://github.com/apache/datafusion-sqlparser-rs/pull/2142) (yoavcloud) - Key Value Options: add support for trailing semicolon [#2140](https://github.com/apache/datafusion-sqlparser-rs/pull/2140) (yoavcloud) - Added support for `ALTER OPERATOR CLASS` syntax [#2135](https://github.com/apache/datafusion-sqlparser-rs/pull/2135) (LucaCappelletti94) - Added missing `Copy` derives [#2158](https://github.com/apache/datafusion-sqlparser-rs/pull/2158) (LucaCappelletti94) - Tokenize empty line comments correctly [#2161](https://github.com/apache/datafusion-sqlparser-rs/pull/2161) (zyuiop) - Add support for DuckDB `LAMBDA` keyword syntax [#2149](https://github.com/apache/datafusion-sqlparser-rs/pull/2149) (lovasoa) - MySQL: Add support for casting using the BINARY keyword [#2146](https://github.com/apache/datafusion-sqlparser-rs/pull/2146) (yoavcloud) - Added missing `From` impls for `Statement` variants [#2160](https://github.com/apache/datafusion-sqlparser-rs/pull/2160) (LucaCappelletti94) - GenericDialect: support colon operator for JsonAccess [#2124](https://github.com/apache/datafusion-sqlparser-rs/pull/2124) (Samyak2) - Databricks: Support Timetravel With "VERSION AS OF" [#2155](https://github.com/apache/datafusion-sqlparser-rs/pull/2155) (JamesVorder) - Fixed truncate table if exists for snowflake [#2166](https://github.com/apache/datafusion-sqlparser-rs/pull/2166) (romanoff) - Refactor: replace some `dialect_of!` checks with `Dialect` trait methods [#2171](https://github.com/apache/datafusion-sqlparser-rs/pull/2171) (andygrove) - MySQL: Support `CAST(... AS ... ARRAY)` syntax [#2151](https://github.com/apache/datafusion-sqlparser-rs/pull/2151) (mvzink) - Snowflake: Support SAMPLE clause on subqueries [#2164](https://github.com/apache/datafusion-sqlparser-rs/pull/2164) (finchxxia) - refactor: use `to_ident()` instead of `clone().into_ident()` for borrowed Words [#2177](https://github.com/apache/datafusion-sqlparser-rs/pull/2177) (andygrove) - Refactor: replace more `dialect_of!` checks with `Dialect` trait methods [#2175](https://github.com/apache/datafusion-sqlparser-rs/pull/2175) (andygrove) - minor: reduce unnecessary string allocations [#2178](https://github.com/apache/datafusion-sqlparser-rs/pull/2178) (andygrove) - PostgreSQL: Support force row level security [#2169](https://github.com/apache/datafusion-sqlparser-rs/pull/2169) (isaacparker0) - PostgreSQL: Add support for `*` (descendant) option in TRUNCATE [#2181](https://github.com/apache/datafusion-sqlparser-rs/pull/2181) (mvzink) - Fix identifier parsing not breaking on the `|>` pipe operator [#2156](https://github.com/apache/datafusion-sqlparser-rs/pull/2156) (alexander-beedie) - [MySQL, Oracle] Parse optimizer hints [#2162](https://github.com/apache/datafusion-sqlparser-rs/pull/2162) (xitep) - Redshift: Support implicit string concatenation using newline [#2167](https://github.com/apache/datafusion-sqlparser-rs/pull/2167) (yoavcloud) - PostgreSQL: Fix REPLICA IDENTITY to use NOTHING [#2179](https://github.com/apache/datafusion-sqlparser-rs/pull/2179) (mvzink) - Add ENFORCED/NOT ENFORCED support for column-level CHECK constraints [#2180](https://github.com/apache/datafusion-sqlparser-rs/pull/2180) (mvzink) - Implement `core::error::Error` for `ParserError` and `TokenizerError` [#2189](https://github.com/apache/datafusion-sqlparser-rs/pull/2189) (LucaCappelletti94) - Moved more structs outside of Statement to facilitate reuse [#2188](https://github.com/apache/datafusion-sqlparser-rs/pull/2188) (LucaCappelletti94) - Fix parsing cast operator after parenthesized `DEFAULT` expression [#2168](https://github.com/apache/datafusion-sqlparser-rs/pull/2168) (isaacparker0) - Streamlined derivation of new `Dialect` objects [#2174](https://github.com/apache/datafusion-sqlparser-rs/pull/2174) (alexander-beedie) - MSSQL: Support standalone BEGIN...END blocks [#2186](https://github.com/apache/datafusion-sqlparser-rs/pull/2186) (guan404ming) - MySQL: Add support for `SELECT` modifiers [#2172](https://github.com/apache/datafusion-sqlparser-rs/pull/2172) (mvzink) - MySQL: Add support for DEFAULT CHARACTER SET in CREATE DATABASE [#2182](https://github.com/apache/datafusion-sqlparser-rs/pull/2182) (mvzink) - [Oracle] Support hierarchical queries [#2185](https://github.com/apache/datafusion-sqlparser-rs/pull/2185) (xitep) - MySQL: Allow optional constraint name after CONSTRAINT keyword [#2183](https://github.com/apache/datafusion-sqlparser-rs/pull/2183) (mvzink) - Added missing derives to dialect marker structs [#2191](https://github.com/apache/datafusion-sqlparser-rs/pull/2191) (LucaCappelletti94) - Fixed overflow error, recursion counter was not included for parenthesis [#2199](https://github.com/apache/datafusion-sqlparser-rs/pull/2199) (LucaCappelletti94) - Add support for C-style comments [#2034](https://github.com/apache/datafusion-sqlparser-rs/pull/2034) (altmannmarcelo) - PostgreSQL: Support PostgreSQL ANALYZE with optional table and column [#2187](https://github.com/apache/datafusion-sqlparser-rs/pull/2187) (guan404ming) - Add Tokenizer custom token mapper support [#2184](https://github.com/apache/datafusion-sqlparser-rs/pull/2184) (askalt) - Fix MAP literals parsing [#2205](https://github.com/apache/datafusion-sqlparser-rs/pull/2205) (Samyak2) ## Credits Thank you to everyone who contributed to this release. Here is a breakdown of commits (PRs merged) per contributor. ``` 9 Luca Cappelletti 9 Yoav Cohen 8 Michael Victor Zink 7 xitep 6 Andy Grove 4 Andriy Romanov 2 Alexander Beedie 2 Andrew Lamb 2 Guan-Ming (Wesley) Chiu 2 James Vorderbruggen 2 Samyak Sarnayak 2 isaacparker0 2 jnlt3 1 Albert Skalt 1 Denis Goncharenko 1 Filipe Guerreiro 1 Louis Vialar 1 Marcelo Altmann 1 Martin Grigorov 1 Ophir LOJKINE 1 Simon Sawert 1 finchxxia ``` Thank you also to everyone who contributed in other ways such as filing issues, reviewing PRs, and providing feedback on this release. apache-datafusion-sqlparser-rs-0.62.0/changelog/0.62.0.md000066400000000000000000000302351517524037000226120ustar00rootroot00000000000000 # sqlparser-rs 0.62.0 Changelog This release consists of 79 commits from 27 contributors. See credits at the end of this changelog for more information. **Implemented enhancements:** - feat(clickhouse): support PARTITION BY after ORDER BY and ARRAY JOIN [#2283](https://github.com/apache/datafusion-sqlparser-rs/pull/2283) (cristhiank) **Other:** - Fix panic on incomplete REGEXP/MATCH expressions in SQLite dialect [#2197](https://github.com/apache/datafusion-sqlparser-rs/pull/2197) (LucaCappelletti94) - chore: add confirmation before tarball is released [#2208](https://github.com/apache/datafusion-sqlparser-rs/pull/2208) (milenkovicm) - Databricks: Add support for `OPTIMIZE`, `PARTITIONED BY`, and `STRUCT` [#2170](https://github.com/apache/datafusion-sqlparser-rs/pull/2170) (funcpp) - Fix panic in `SET AUTHORIZATION` parsing when scope modifier is missing [#2201](https://github.com/apache/datafusion-sqlparser-rs/pull/2201) (LucaCappelletti94) - Snowflake: Add multi table insert support [#2148](https://github.com/apache/datafusion-sqlparser-rs/pull/2148) (finchxxia) - MSSQL: Support `THROW` statement [#2202](https://github.com/apache/datafusion-sqlparser-rs/pull/2202) (guan404ming) - Updated Fuzzer harness to address all dialects [#2203](https://github.com/apache/datafusion-sqlparser-rs/pull/2203) (RPG-Alex) - Snowflake: Lambda functions [#2192](https://github.com/apache/datafusion-sqlparser-rs/pull/2192) (yoavcloud) - Updated `parse_infix(..)` in `mysql.rs` and `sqlite.rs` to handle error rather than `unwrap()` [#2207](https://github.com/apache/datafusion-sqlparser-rs/pull/2207) (RPG-Alex) - MSSQL: Add support for TRAN shorthand [#2212](https://github.com/apache/datafusion-sqlparser-rs/pull/2212) (guan404ming) - Fixed select dollar column from stage for snowflake [#2165](https://github.com/apache/datafusion-sqlparser-rs/pull/2165) (romanoff) - [PIVOT] Optional AS keyword for aliases [#2209](https://github.com/apache/datafusion-sqlparser-rs/pull/2209) (xitep) - Fix `derive_dialect!` proc macro for use from external crates [#2219](https://github.com/apache/datafusion-sqlparser-rs/pull/2219) (alexander-beedie) - Resolve breaking change that set "supports_lambda_functions" on `GenericDialect` [#2224](https://github.com/apache/datafusion-sqlparser-rs/pull/2224) (alexander-beedie) - MSSQL: Add support for WAITFOR statement [#2210](https://github.com/apache/datafusion-sqlparser-rs/pull/2210) (guan404ming) - PostgreSQL: Support PRIMARY KEY/UNIQUE USING INDEX [#2213](https://github.com/apache/datafusion-sqlparser-rs/pull/2213) (guan404ming) - Prefer use of `peek_token_ref` over `peek_token` where valid [#2225](https://github.com/apache/datafusion-sqlparser-rs/pull/2225) (alexander-beedie) - PostgreSQL: Support more COMMENT ON object types [#2220](https://github.com/apache/datafusion-sqlparser-rs/pull/2220) (guan404ming) - Allow custom OptimizerHints [#2216](https://github.com/apache/datafusion-sqlparser-rs/pull/2216) (altmannmarcelo) - Optimise out string allocations and copies in keyword lookup [#2226](https://github.com/apache/datafusion-sqlparser-rs/pull/2226) (alexander-beedie) - [Oracle] Table alias for INSERTed table [#2214](https://github.com/apache/datafusion-sqlparser-rs/pull/2214) (xitep) - Introduce `Visit::visit_select` [#2235](https://github.com/apache/datafusion-sqlparser-rs/pull/2235) (xitep) - Add support for INTERVAL keyword as unquoted identifier in PostgreSQL [#2238](https://github.com/apache/datafusion-sqlparser-rs/pull/2238) (LucaCappelletti94) - Redshift: support wildcard select items with alias [#2230](https://github.com/apache/datafusion-sqlparser-rs/pull/2230) (yoabot-droid) - Snowflake: support wildcard with EXCLUDE in function arguments [#2231](https://github.com/apache/datafusion-sqlparser-rs/pull/2231) (yoabot-droid) - MSSQL: prevent statement-starting keywords from being consumed as implicit aliases [#2233](https://github.com/apache/datafusion-sqlparser-rs/pull/2233) (yoabot-droid) - Support parenthesized `CREATE TABLE ... (LIKE ... INCLUDING/EXCLUDING DEFAULTS)` in `PostgreSQL` [#2242](https://github.com/apache/datafusion-sqlparser-rs/pull/2242) (LucaCappelletti94) - MSSQL: support EXEC (@sql) dynamic SQL execution [#2234](https://github.com/apache/datafusion-sqlparser-rs/pull/2234) (yoabot-droid) - Support MySQL KEY keyword in column definitions [#2243](https://github.com/apache/datafusion-sqlparser-rs/pull/2243) (mvzink) - Support two-argument `TRIM(string, characters)` in PostgreSQL [#2240](https://github.com/apache/datafusion-sqlparser-rs/pull/2240) (LucaCappelletti94) - Add Readyset to users in README.md [#2247](https://github.com/apache/datafusion-sqlparser-rs/pull/2247) (mvzink) - Snowflake: parse EXCLUDE column list as ObjectName to support qualified names [#2244](https://github.com/apache/datafusion-sqlparser-rs/pull/2244) (yoabot-droid) - MSSQL: Add support for OUTPUT clause on INSERT/UPDATE/DELETE [#2228](https://github.com/apache/datafusion-sqlparser-rs/pull/2228) (guan404ming) - Redshift: Added DISTSTYLE and DISTKEY keywords parsing [#2222](https://github.com/apache/datafusion-sqlparser-rs/pull/2222) (romanoff) - Allow INSERT columns to be qualified [#2260](https://github.com/apache/datafusion-sqlparser-rs/pull/2260) (xitep) - Add support for parsing COPY statements from STDIN without a semicolon [#2245](https://github.com/apache/datafusion-sqlparser-rs/pull/2245) (LucaCappelletti94) - Fix credentials parsing for redshift [#2262](https://github.com/apache/datafusion-sqlparser-rs/pull/2262) (romanoff) - Added SORTKEY keyword parsing for redshift queries [#2261](https://github.com/apache/datafusion-sqlparser-rs/pull/2261) (romanoff) - Fixed transaction handling for snowflake [#2263](https://github.com/apache/datafusion-sqlparser-rs/pull/2263) (romanoff) - Fixed COPY GRANTS clause parsing for snowflake [#2267](https://github.com/apache/datafusion-sqlparser-rs/pull/2267) (romanoff) - Fixed parsing `OPTIONS(format = 'CSV')` when creating external bigquery table [#2268](https://github.com/apache/datafusion-sqlparser-rs/pull/2268) (romanoff) - Add support for PostgreSQL LOCK TABLE [#2273](https://github.com/apache/datafusion-sqlparser-rs/pull/2273) (mjbshaw) - add support for databricks JSON accessors [#2272](https://github.com/apache/datafusion-sqlparser-rs/pull/2272) (whirlun) - Fixed create snapshot table for bigquery [#2269](https://github.com/apache/datafusion-sqlparser-rs/pull/2269) (romanoff) - Fixed stage name parsing for snowflake [#2265](https://github.com/apache/datafusion-sqlparser-rs/pull/2265) (romanoff) - Fix STORAGE LIFECYCLE POLICY for snowflake queries [#2264](https://github.com/apache/datafusion-sqlparser-rs/pull/2264) (romanoff) - Fixed CHANGES keyword parsing for snowflake [#2266](https://github.com/apache/datafusion-sqlparser-rs/pull/2266) (romanoff) - Add SETOF support for PostgreSQL function return types [#2217](https://github.com/apache/datafusion-sqlparser-rs/pull/2217) (fmguerreiro) - [Oracle] Support for `INSERT INTO () ...` [#2276](https://github.com/apache/datafusion-sqlparser-rs/pull/2276) (xitep) - Fixed BACKUP parsing for redshift [#2270](https://github.com/apache/datafusion-sqlparser-rs/pull/2270) (romanoff) - recursive protection for `parse_subexpr` [#2282](https://github.com/apache/datafusion-sqlparser-rs/pull/2282) (blaginin) - Fix the tokenization of `<` edge cases [#2280](https://github.com/apache/datafusion-sqlparser-rs/pull/2280) (ayman-sigma) - Expose values through ValueWithSpan [#2281](https://github.com/apache/datafusion-sqlparser-rs/pull/2281) (xitep) - Enable `!` as NOT operator for Databricks dialect [#2287](https://github.com/apache/datafusion-sqlparser-rs/pull/2287) (funcpp) - Add dollar prefix support for money constants in MSSQL [#2285](https://github.com/apache/datafusion-sqlparser-rs/pull/2285) (solontsev) - Allow bare columns in GROUPING SETS expressions [#2288](https://github.com/apache/datafusion-sqlparser-rs/pull/2288) (funcpp) - Enable numeric-prefix identifiers for Databricks dialect [#2290](https://github.com/apache/datafusion-sqlparser-rs/pull/2290) (funcpp) - Enable Redshift support for specifying null treatment inside window function [#2293](https://github.com/apache/datafusion-sqlparser-rs/pull/2293) (romanb) - Fix parsing EXECUTE (...) with a more general string expression [#2295](https://github.com/apache/datafusion-sqlparser-rs/pull/2295) (romanb) - Support optional AS keyword in CTE definitions for Databricks [#2286](https://github.com/apache/datafusion-sqlparser-rs/pull/2286) (funcpp) - MySQL: Add support for `ORDER BY` on single-table `UPDATE` [#2296](https://github.com/apache/datafusion-sqlparser-rs/pull/2296) (tpyo) - Support multi-column aliases in SELECT items [#2289](https://github.com/apache/datafusion-sqlparser-rs/pull/2289) (funcpp) - MySQL: Support `SHOW FULL PROCESSLIST` syntax [#2292](https://github.com/apache/datafusion-sqlparser-rs/pull/2292) (jstnd) - PostgreSQL `ALTER FUNCTION` / `ALTER AGGREGATE` [#2248](https://github.com/apache/datafusion-sqlparser-rs/pull/2248) (LucaCappelletti94) - Add xml '...' TypedString support for PostgreSQL [#2299](https://github.com/apache/datafusion-sqlparser-rs/pull/2299) (LucaCappelletti94) - Add PostgreSQL Collation DDL Support [#2249](https://github.com/apache/datafusion-sqlparser-rs/pull/2249) (LucaCappelletti94) - Fix COLLATE parsing after compound identifiers [#2294](https://github.com/apache/datafusion-sqlparser-rs/pull/2294) (romanb) - Redshift/PostgreSQL: Parse optional implicit aliases for wildcard select items [#2300](https://github.com/apache/datafusion-sqlparser-rs/pull/2300) (yoavcloud) - Only parse FROM identifier in CTE if using Hive [#2241](https://github.com/apache/datafusion-sqlparser-rs/pull/2241) (Viicos) - Add SHOW CATALOGS syntax and tests [#2284](https://github.com/apache/datafusion-sqlparser-rs/pull/2284) (Smith-Cruise) - Coding agents guidelines [#2298](https://github.com/apache/datafusion-sqlparser-rs/pull/2298) (yoavcloud) - Spark SQL: Add SparkSqlDialect [#2305](https://github.com/apache/datafusion-sqlparser-rs/pull/2305) (andygrove) - PostgreSQL: Add support for LATERAL ... WITH ORDINALITY [#2304](https://github.com/apache/datafusion-sqlparser-rs/pull/2304) (yoavcloud) - Track `Parens`'s span [#2291](https://github.com/apache/datafusion-sqlparser-rs/pull/2291) (xitep) - Redshift: PartiQL AT [#2303](https://github.com/apache/datafusion-sqlparser-rs/pull/2303) (yoavcloud) - Snowflake: Add support for text data type modifiers [#2297](https://github.com/apache/datafusion-sqlparser-rs/pull/2297) (yoavcloud) - PostgreSQL: Parse optimizer hints in leading comments [#2320](https://github.com/apache/datafusion-sqlparser-rs/pull/2320) (altmannmarcelo) - Add Teradata dialect [#2309](https://github.com/apache/datafusion-sqlparser-rs/pull/2309) (iffyio) ## Credits Thank you to everyone who contributed to this release. Here is a breakdown of commits (PRs merged) per contributor. ``` 12 Andriy Romanov 9 Luca Cappelletti 7 xitep 6 Guan-Ming (Wesley) Chiu 6 Minjun Kim 6 Yoav Cohen 5 Yoabot 4 Alexander Beedie 3 Roman Borschel 2 Alex 2 Marcelo Altmann 2 Michael Victor Zink 1 Andy Grove 1 Ayman Elkfrawy 1 Cristhian Lopez 1 Dmitrii Blaginin 1 Donovan Schönknecht 1 Filipe Guerreiro 1 Ifeanyi Ubah 1 Marko Milenković 1 Michael Bradshaw 1 Sergey Olontsev 1 Smith Cruise 1 Victorien 1 finchxxia 1 jstnd 1 whirlun ``` Thank you also to everyone who contributed in other ways such as filing issues, reviewing PRs, and providing feedback on this release. apache-datafusion-sqlparser-rs-0.62.0/derive/000077500000000000000000000000001517524037000210715ustar00rootroot00000000000000apache-datafusion-sqlparser-rs-0.62.0/derive/Cargo.toml000066400000000000000000000026721517524037000230300ustar00rootroot00000000000000# 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. [package] name = "sqlparser_derive" description = "Procedural (proc) macros for sqlparser" version = "0.5.0" authors = ["sqlparser-rs authors"] homepage = "https://github.com/sqlparser-rs/sqlparser-rs" documentation = "https://docs.rs/sqlparser_derive/" keywords = ["ansi", "sql", "lexer", "parser"] repository = "https://github.com/sqlparser-rs/sqlparser-rs" license = "Apache-2.0" include = [ "src/**/*.rs", "Cargo.toml", "LICENSE.TXT", ] edition = "2021" [lib] proc-macro = true [dependencies] syn = { version = "2.0", default-features = false, features = ["full", "printing", "parsing", "derive", "proc-macro", "clone-impls"] } proc-macro2 = "1.0" quote = "1.0" apache-datafusion-sqlparser-rs-0.62.0/derive/LICENSE.TXT000077700000000000000000000000001517524037000244452../LICENSE.TXTustar00rootroot00000000000000apache-datafusion-sqlparser-rs-0.62.0/derive/README.md000066400000000000000000000134001517524037000223460ustar00rootroot00000000000000 # SQL Parser Derive Macro ## Visit This crate contains a procedural macro that can automatically derive implementations of the `Visit` trait in the [sqlparser](https://crates.io/crates/sqlparser) crate ```rust #[derive(Visit, VisitMut)] struct Foo { boolean: bool, bar: Bar, } #[derive(Visit, VisitMut)] enum Bar { A(), B(String, bool), C { named: i32 }, } ``` Will generate code akin to ```rust impl Visit for Foo { fn visit(&self, visitor: &mut V) -> ControlFlow { self.boolean.visit(visitor)?; self.bar.visit(visitor)?; ControlFlow::Continue(()) } } impl Visit for Bar { fn visit(&self, visitor: &mut V) -> ControlFlow { match self { Self::A() => {} Self::B(_1, _2) => { _1.visit(visitor)?; _2.visit(visitor)?; } Self::C { named } => { named.visit(visitor)?; } } ControlFlow::Continue(()) } } ``` Some types may wish to call a corresponding method on the visitor: ```rust #[derive(Visit, VisitMut)] #[visit(with = "visit_expr")] enum Expr { IsNull(Box), .. } ``` This will result in the following sequence of visitor calls when an `IsNull` expression is visited ``` visitor.pre_visit_expr() visitor.pre_visit_expr() visitor.post_visit_expr() visitor.post_visit_expr() ``` For some types it is only appropriate to call a particular visitor method in some contexts. For example, not every `ObjectName` refers to a relation. In these cases, the `visit` attribute can be used on the field for which we'd like to call the method: ```rust #[derive(Visit, VisitMut)] #[visit(with = "visit_table_factor")] pub enum TableFactor { Table { #[visit(with = "visit_relation")] name: ObjectName, alias: Option, }, .. } ``` This will generate ```rust impl Visit for TableFactor { fn visit(&self, visitor: &mut V) -> ControlFlow { visitor.pre_visit_table_factor(self)?; match self { Self::Table { name, alias } => { visitor.pre_visit_relation(name)?; name.visit(visitor)?; visitor.post_visit_relation(name)?; alias.visit(visitor)?; } } visitor.post_visit_table_factor(self)?; ControlFlow::Continue(()) } } ``` Note that annotating both the type and the field is incorrect as it will result in redundant calls to the method. For example ```rust #[derive(Visit, VisitMut)] #[visit(with = "visit_expr")] enum Expr { IsNull(#[visit(with = "visit_expr")] Box), .. } ``` will result in these calls to the visitor ``` visitor.pre_visit_expr() visitor.pre_visit_expr() visitor.pre_visit_expr() visitor.post_visit_expr() visitor.post_visit_expr() visitor.post_visit_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, #[cfg_attr(feature = "visitor", visit(with = "visit_relation"))] pub parent_name: Option, } ``` This will generate ```rust impl sqlparser::ast::Visit for ShowStatementIn { fn visit( &self, visitor: &mut V, ) -> ::std::ops::ControlFlow { 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( &mut self, visitor: &mut V, ) -> ::std::ops::ControlFlow { 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 Steps: 1. Update the version in `Cargo.toml` 2. Update the corresponding version in `../Cargo.toml` 3. Commit via PR 4. Publish to crates.io: ```shell # update to latest checked in main branch and publish via cargo publish ``` apache-datafusion-sqlparser-rs-0.62.0/derive/src/000077500000000000000000000000001517524037000216605ustar00rootroot00000000000000apache-datafusion-sqlparser-rs-0.62.0/derive/src/dialect.rs000066400000000000000000000313141517524037000236350ustar00rootroot00000000000000// 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. //! Implementation of the `derive_dialect!` macro for creating custom SQL dialects. use proc_macro2::TokenStream; use quote::{quote, quote_spanned}; use std::collections::HashSet; use syn::{ braced, parse::{Parse, ParseStream}, Error, File, FnArg, Ident, Item, LitBool, LitChar, Pat, ReturnType, Signature, Token, TraitItem, Type, }; /// Override value types supported by the macro pub(crate) enum Override { Bool(LitBool), Char(LitChar), None, } /// Parsed input for the `derive_dialect!` macro pub(crate) struct DeriveDialectInput { pub name: Ident, pub base: Type, pub preserve_type_id: bool, pub overrides: Vec<(Ident, Override)>, } /// `Dialect` trait method attrs struct DialectMethod { name: Ident, signature: Signature, } impl Parse for DeriveDialectInput { fn parse(input: ParseStream) -> syn::Result { let name: Ident = input.parse()?; input.parse::()?; let base: Type = input.parse()?; let mut preserve_type_id = false; let mut overrides = Vec::new(); while input.peek(Token![,]) { input.parse::()?; if input.is_empty() { break; } if input.peek(Ident) { let ident: Ident = input.parse()?; match ident.to_string().as_str() { "preserve_type_id" => { input.parse::()?; preserve_type_id = input.parse::()?.value(); } "overrides" => { input.parse::()?; let content; braced!(content in input); while !content.is_empty() { let key: Ident = content.parse()?; content.parse::()?; let value = if content.peek(LitBool) { Override::Bool(content.parse()?) } else if content.peek(LitChar) { Override::Char(content.parse()?) } else if content.peek(Ident) { let ident: Ident = content.parse()?; if ident == "None" { Override::None } else { return Err(Error::new( ident.span(), format!("Expected `true`, `false`, a char, or `None`, found `{ident}`"), )); } } else { return Err( content.error("Expected `true`, `false`, a char, or `None`") ); }; overrides.push((key, value)); if content.peek(Token![,]) { content.parse::()?; } } } other => { return Err(Error::new(ident.span(), format!( "Unknown argument `{other}`. Expected `preserve_type_id` or `overrides`." ))); } } } } Ok(DeriveDialectInput { name, base, preserve_type_id, overrides, }) } } /// Entry point for the `derive_dialect!` macro pub(crate) fn derive_dialect(input: DeriveDialectInput) -> proc_macro::TokenStream { match derive_dialect_inner(input) { Ok(tokens) => tokens.into(), Err(e) => e.to_compile_error().into(), } } fn derive_dialect_inner(input: DeriveDialectInput) -> syn::Result { let call_site = proc_macro2::Span::call_site(); let source = read_dialect_mod_file() .map_err(|e| Error::new(call_site, format!("Failed to read dialect/mod.rs: {e}")))?; let file: File = syn::parse_str::(&source) .map_err(|e| Error::new(call_site, format!("Failed to parse source: {e}")))?; let methods = extract_dialect_methods(&file)?; // Validate overrides let bool_names: HashSet<_> = methods .iter() .filter(|m| is_bool_method(&m.signature)) .map(|m| m.name.to_string()) .collect(); for (key, value) in &input.overrides { let key_str = key.to_string(); match value { Override::Bool(_) if !bool_names.contains(&key_str) => { return Err(Error::new( key.span(), format!("Unknown boolean method `{key_str}`"), )); } Override::Char(_) | Override::None if key_str != "identifier_quote_style" => { return Err(Error::new( key.span(), format!("Char/None only valid for `identifier_quote_style`, not `{key_str}`"), )); } _ => {} } } Ok(generate_derived_dialect(&input, &methods)) } /// Generate the complete derived `Dialect` implementation fn generate_derived_dialect(input: &DeriveDialectInput, methods: &[DialectMethod]) -> TokenStream { let name = &input.name; let base = &input.base; // Helper to find an override by method name let find_override = |method_name: &str| { input .overrides .iter() .find(|(k, _)| k == method_name) .map(|(_, v)| v) }; // Helper to generate delegation to base dialect let delegate = |method: &DialectMethod| { let sig = &method.signature; let method_name = &method.name; let params = extract_param_names(sig); quote_spanned! { method_name.span() => #sig { self.dialect.#method_name(#(#params),*) } } }; // Generate the struct let struct_def = quote_spanned! { name.span() => #[derive(Debug, Default)] pub struct #name { dialect: #base, } impl #name { pub fn new() -> Self { Self::default() } } }; // Generate TypeId method body let type_id_body = if input.preserve_type_id { quote! { Dialect::dialect(&self.dialect) } } else { quote! { ::core::any::TypeId::of::<#name>() } }; // Generate method implementations let method_impls = methods.iter().map(|method| { let method_name = &method.name; match find_override(&method_name.to_string()) { Some(Override::Bool(value)) => { quote_spanned! { method_name.span() => fn #method_name(&self) -> bool { #value } } } Some(Override::Char(c)) => { quote_spanned! { method_name.span() => fn identifier_quote_style(&self, _: &str) -> Option { Some(#c) } } } Some(Override::None) => { quote_spanned! { method_name.span() => fn identifier_quote_style(&self, _: &str) -> Option { None } } } None => delegate(method), } }); // Wrap impl in a const block with scoped imports so types resolve without qualification quote! { #struct_def const _: () = { use ::core::iter::Peekable; use ::core::str::Chars; use sqlparser::ast::{ColumnOption, Expr, GranteesType, Ident, ObjectNamePart, Statement}; use sqlparser::dialect::{Dialect, Precedence}; use sqlparser::keywords::Keyword; use sqlparser::parser::{Parser, ParserError}; impl Dialect for #name { fn dialect(&self) -> ::core::any::TypeId { #type_id_body } #(#method_impls)* } }; } } /// Extract parameter names from a method signature (excluding self) fn extract_param_names(sig: &Signature) -> Vec<&Ident> { sig.inputs .iter() .filter_map(|arg| match arg { FnArg::Typed(pt) => match pt.pat.as_ref() { Pat::Ident(pi) => Some(&pi.ident), _ => None, }, _ => None, }) .collect() } /// Read the `dialect/mod.rs` file that contains the Dialect trait. /// /// Searches for the file in the following order: /// 1. `$CARGO_MANIFEST_DIR/src/dialect/mod.rs` - works when the macro is /// invoked from within the `sqlparser` crate itself (e.g. in tests). /// 2. `/../src/dialect/mod.rs` - works when /// `sqlparser_derive` lives in a workspace alongside the main crate /// (the standard `derive/` layout). /// 3. Sibling directories of the compiled `sqlparser_derive` crate in the /// Cargo registry - works when an external crate uses `derive_dialect!` /// via a registry dependency. fn read_dialect_mod_file() -> Result { use std::path::{Path, PathBuf}; const DERIVE_CRATE_DIR: &str = env!("CARGO_MANIFEST_DIR"); let derive_dir = Path::new(DERIVE_CRATE_DIR); let mut candidates: Vec = Vec::new(); // The crate being compiled (eg: within sqlparser). if let Ok(manifest_dir) = std::env::var("CARGO_MANIFEST_DIR") { candidates.push(Path::new(&manifest_dir).join("src/dialect/mod.rs")); } // Workspace layout: the main crate is the parent of `derive/`. candidates.push(derive_dir.join("../src/dialect/mod.rs")); // Cargo registry: look for sibling `sqlparser-*` directories (prefer newest). if let Some(parent) = derive_dir.parent() { if let Ok(entries) = std::fs::read_dir(parent) { let mut siblings: Vec<_> = entries .filter_map(|e| e.ok()) .filter(|e| { let name = e.file_name(); let name = name.to_string_lossy(); name.starts_with("sqlparser-") && !name.starts_with("sqlparser-derive") }) .collect(); siblings.sort_by(|a, b| b.file_name().cmp(&a.file_name())); candidates.extend( siblings .into_iter() .map(|e| e.path().join("src/dialect/mod.rs")), ); } } for path in &candidates { if let Ok(content) = std::fs::read_to_string(path) { return Ok(content); } } Err(format!( "Could not find `sqlparser` dialect/mod.rs file. \ Searched in $CARGO_MANIFEST_DIR/src/dialect/mod.rs and \ the `sqlparser_derive` crate at {DERIVE_CRATE_DIR}" )) } /// Extract all methods from the `Dialect` trait (excluding `dialect` for TypeId) fn extract_dialect_methods(file: &File) -> Result, Error> { let dialect_trait = file .items .iter() .find_map(|item| match item { Item::Trait(t) if t.ident == "Dialect" => Some(t), _ => None, }) .ok_or_else(|| Error::new(proc_macro2::Span::call_site(), "Dialect trait not found"))?; let mut methods: Vec<_> = dialect_trait .items .iter() .filter_map(|item| match item { TraitItem::Fn(m) if m.sig.ident != "dialect" => Some(DialectMethod { name: m.sig.ident.clone(), signature: m.sig.clone(), }), _ => None, }) .collect(); methods.sort_by_key(|m| m.name.to_string()); Ok(methods) } /// Check if a method signature is `fn name(&self) -> bool` fn is_bool_method(sig: &Signature) -> bool { sig.inputs.len() == 1 && matches!( sig.inputs.first(), Some(FnArg::Receiver(r)) if r.reference.is_some() && r.mutability.is_none() ) && matches!( &sig.output, ReturnType::Type(_, ty) if matches!(ty.as_ref(), Type::Path(p) if p.path.is_ident("bool")) ) } apache-datafusion-sqlparser-rs-0.62.0/derive/src/lib.rs000066400000000000000000000042741517524037000230030ustar00rootroot00000000000000// 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. //! Procedural macros for sqlparser. //! //! This crate provides: //! - [`Visit`] and [`VisitMut`] derive macros for AST traversal. //! - [`derive_dialect!`] macro for creating custom SQL dialects. use quote::quote; use syn::parse_macro_input; mod dialect; mod visit; /// Implementation of `#[derive(VisitMut)]` #[proc_macro_derive(VisitMut, attributes(visit))] pub fn derive_visit_mut(input: proc_macro::TokenStream) -> proc_macro::TokenStream { let input = parse_macro_input!(input as syn::DeriveInput); visit::derive_visit( input, &visit::VisitType { visit_trait: quote!(VisitMut), visitor_trait: quote!(VisitorMut), modifier: Some(quote!(mut)), }, ) } /// Implementation of `#[derive(Visit)]` #[proc_macro_derive(Visit, attributes(visit))] pub fn derive_visit_immutable(input: proc_macro::TokenStream) -> proc_macro::TokenStream { let input = parse_macro_input!(input as syn::DeriveInput); visit::derive_visit( input, &visit::VisitType { visit_trait: quote!(Visit), visitor_trait: quote!(Visitor), modifier: None, }, ) } /// Procedural macro for deriving new SQL dialects. #[proc_macro] pub fn derive_dialect(input: proc_macro::TokenStream) -> proc_macro::TokenStream { let input = parse_macro_input!(input as dialect::DeriveDialectInput); dialect::derive_dialect(input) } apache-datafusion-sqlparser-rs-0.62.0/derive/src/visit.rs000066400000000000000000000231161517524037000233670ustar00rootroot00000000000000// 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. //! Implementation of the `Visit` and `VisitMut` derive macros. use proc_macro2::TokenStream; use quote::{format_ident, quote, quote_spanned, ToTokens}; use syn::spanned::Spanned; use syn::{ parse::{Parse, ParseStream}, parse_quote, Attribute, Data, Fields, GenericParam, Generics, Ident, Index, LitStr, Meta, Token, Type, TypePath, }; use syn::{Path, PathArguments}; pub(crate) struct VisitType { pub visit_trait: TokenStream, pub visitor_trait: TokenStream, pub modifier: Option, } pub(crate) fn derive_visit( input: syn::DeriveInput, visit_type: &VisitType, ) -> proc_macro::TokenStream { let name = input.ident; let VisitType { visit_trait, visitor_trait, modifier, } = visit_type; let attributes = Attributes::parse(&input.attrs); // Add a bound `T: Visit` to every type parameter T. let generics = add_trait_bounds(input.generics, visit_type); let (impl_generics, ty_generics, where_clause) = generics.split_for_impl(); let (pre_visit, post_visit) = attributes.visit(quote!(self)); let children = visit_children(&input.data, visit_type); 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( &#modifier self, visitor: &mut V ) -> ::std::ops::ControlFlow { #pre_visit #children #post_visit ::std::ops::ControlFlow::Continue(()) } } }; proc_macro::TokenStream::from(expanded) } /// Parses attributes that can be provided to this macro /// /// `#[visit(leaf, with = "visit_expr")]` #[derive(Default)] struct Attributes { /// Content for the `with` attribute with: Option, } struct WithIdent { with: Option, } impl Parse for WithIdent { fn parse(input: ParseStream) -> Result { let mut result = WithIdent { with: None }; let ident = input.parse::()?; if ident != "with" { return Err(syn::Error::new( ident.span(), "Expected identifier to be `with`", )); } input.parse::()?; let s = input.parse::()?; result.with = Some(format_ident!("{}", s.value(), span = s.span())); Ok(result) } } impl Attributes { fn parse(attrs: &[Attribute]) -> Self { let mut out = Self::default(); for attr in attrs { if let Meta::List(ref metalist) = attr.meta { if metalist.path.is_ident("visit") { match syn::parse2::(metalist.tokens.clone()) { Ok(with_ident) => { out.with = with_ident.with; } Err(e) => { panic!("{}", e); } } } } } out } /// Returns the pre and post visit token streams fn visit(&self, s: TokenStream) -> (Option, Option) { let pre_visit = self.with.as_ref().map(|m| { let m = format_ident!("pre_{}", m); quote!(visitor.#m(#s)?;) }); let post_visit = self.with.as_ref().map(|m| { let m = format_ident!("post_{}", m); quote!(visitor.#m(#s)?;) }); (pre_visit, post_visit) } } // Add a bound `T: Visit` to every type parameter T. fn add_trait_bounds(mut generics: Generics, VisitType { visit_trait, .. }: &VisitType) -> Generics { for param in &mut generics.params { if let GenericParam::Type(ref mut type_param) = *param { type_param .bounds .push(parse_quote!(sqlparser::ast::#visit_trait)); } } generics } // Generate the body of the visit implementation for the given type fn visit_children( data: &Data, VisitType { visit_trait, modifier, .. }: &VisitType, ) -> TokenStream { match data { Data::Struct(data) => match &data.fields { 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 ) } }); quote! { #(#recurse)* } } Fields::Unnamed(fields) => { let recurse = fields.unnamed.iter().enumerate().map(|(i, f)| { let index = Index::from(i); let attributes = Attributes::parse(&f.attrs); let (pre_visit, post_visit) = attributes.visit(quote!(&self.#index)); quote_spanned!(f.span() => #pre_visit sqlparser::ast::#visit_trait::visit(&#modifier self.#index, visitor)?; #post_visit) }); quote! { #(#recurse)* } } Fields::Unit => { quote!() } }, Data::Enum(data) => { let statements = data.variants.iter().map(|v| { let name = &v.ident; match &v.fields { Fields::Named(fields) => { let names = fields.named.iter().map(|f| &f.ident); let visit = fields.named.iter().map(|f| { let name = &f.ident; let attributes = Attributes::parse(&f.attrs); let (pre_visit, post_visit) = attributes.visit(name.to_token_stream()); quote_spanned!(f.span() => #pre_visit sqlparser::ast::#visit_trait::visit(#name, visitor)?; #post_visit) }); quote!( Self::#name { #(#names),* } => { #(#visit)* } ) } Fields::Unnamed(fields) => { let names = fields.unnamed.iter().enumerate().map(|(i, f)| format_ident!("_{}", i, span = f.span())); let visit = fields.unnamed.iter().enumerate().map(|(i, f)| { let name = format_ident!("_{}", i); let attributes = Attributes::parse(&f.attrs); let (pre_visit, post_visit) = attributes.visit(name.to_token_stream()); quote_spanned!(f.span() => #pre_visit sqlparser::ast::#visit_trait::visit(#name, visitor)?; #post_visit) }); quote! { Self::#name ( #(#names),*) => { #(#visit)* } } } Fields::Unit => { quote! { Self::#name => {} } } } }); quote! { match self { #(#statements),* } } } 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 } apache-datafusion-sqlparser-rs-0.62.0/dev/000077500000000000000000000000001517524037000203715ustar00rootroot00000000000000apache-datafusion-sqlparser-rs-0.62.0/dev/release/000077500000000000000000000000001517524037000220115ustar00rootroot00000000000000apache-datafusion-sqlparser-rs-0.62.0/dev/release/README.md000066400000000000000000000132521517524037000232730ustar00rootroot00000000000000 ## Process Overview As part of the Apache governance model, official releases consist of signed source tarballs approved by the DataFusion PMC. We then use the code in the approved artifacts to release to crates.io. ### Change Log We maintain a `CHANGELOG.md` so our users know what has been changed between releases. You will need a GitHub Personal Access Token for the following steps. Follow [these instructions](https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/creating-a-personal-access-token) to generate one if you do not already have one. The changelog is generated using a Python script which needs `PyGitHub`, installed using pip: ```shell pip3 install PyGitHub ``` To generate the changelog, set the `GITHUB_TOKEN` environment variable to a valid token and then run the script providing two commit ids or tags followed by the version number of the release being created. The following example generates a change log of all changes between the first commit and the current HEAD revision. ```shell export GITHUB_TOKEN= python ./dev/release/generate-changelog.py v0.51.0 HEAD 0.52.0 > changelog/0.52.0.md ``` This script creates a changelog from GitHub PRs based on the labels associated with them as well as looking for titles starting with `feat:`, `fix:`, or `docs:`. Add an entry to CHANGELOG.md for the new version ## Prepare release commits and PR ### Update Version Checkout the main commit to be released ```shell git fetch apache git checkout apache/main ``` Manually update the version in the root `Cargo.toml` to the release version (e.g. `0.52.0`). Lastly commit the version change: ```shell git commit -a -m 'Update version' ``` ## Prepare release candidate artifacts After the PR gets merged, you are ready to create release artifacts from the merged commit. (Note you need to be a committer to run these scripts as they upload to the apache svn distribution servers) ### Pick a Release Candidate (RC) number Pick numbers in sequential order, with `0` for `rc0`, `1` for `rc1`, etc. ### Create git tag for the release: While the official release artifacts are signed tarballs and zip files, we also tag the commit it was created for convenience and code archaeology. Using a string such as `v0.52.0` as the ``, create and push the tag by running these commands: For example to tag version `0.52.0` ```shell git fetch apache git tag v0.52.0-rc1 apache/main # push tag to Github remote git push apache v0.52.0-rc1 ``` ### Create, sign, and upload artifacts Run `create-tarball.sh` with the `` tag and `` and you found in previous steps: ```shell GITHUB_TOKEN= ./dev/release/create-tarball.sh 0.52.0 1 ``` The `create-tarball.sh` script 1. creates and uploads all release candidate artifacts to the [datafusion dev](https://dist.apache.org/repos/dist/dev/datafusion) location on the apache distribution svn server 2. provide you an email template to send to dev@datafusion.apache.org for release voting. ### Vote on Release Candidate artifacts Send the email output from the script to dev@datafusion.apache.org. For the release to become "official" it needs at least three PMC members to vote +1 on it. ### Verifying Release Candidates The `dev/release/verify-release-candidate.sh` is a script in this repository that can assist in the verification process. Run it like: ```shell ./dev/release/verify-release-candidate.sh 0.52.0 1 ``` #### If the release is not approved If the release is not approved, fix whatever the problem is, merge changelog changes into main if there is any and try again with the next RC number. ## Finalize the release NOTE: steps in this section can only be done by PMC members. ### After the release is approved Move artifacts to the release location in SVN, using the `release-tarball.sh` script: ```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! ### Publish on Crates.io Only approved releases of the tarball should be published to crates.io, in order to conform to Apache Software Foundation governance standards. A DataFusion committer can publish this crate after an official project release has been made to crates.io using the following instructions. Follow [these instructions](https://doc.rust-lang.org/cargo/reference/publishing.html) to create an account and login to crates.io before asking to be added as an owner to the sqlparser DataFusion crates. Download and unpack the official release tarball Verify that the Cargo.toml in the tarball contains the correct version (e.g. `version = "0.52.0"`) and then publish the crates by running the following commands ```shell cargo publish ``` If necessary, also publish the `sqlparser_derive` crate: crates.io homepage: https://crates.io/crates/sqlparser_derive ```shell (cd derive && cargo publish ``` apache-datafusion-sqlparser-rs-0.62.0/dev/release/check-rat-report.py000066400000000000000000000036751517524037000255500ustar00rootroot00000000000000#!/usr/bin/python ############################################################################## # 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. ############################################################################## import fnmatch import re import sys import xml.etree.ElementTree as ET if len(sys.argv) != 3: sys.stderr.write("Usage: %s exclude_globs.lst rat_report.xml\n" % sys.argv[0]) sys.exit(1) exclude_globs_filename = sys.argv[1] xml_filename = sys.argv[2] globs = [line.strip() for line in open(exclude_globs_filename, "r")] tree = ET.parse(xml_filename) root = tree.getroot() resources = root.findall('resource') all_ok = True for r in resources: approvals = r.findall('license-approval') if not approvals or approvals[0].attrib['name'] == 'true': continue clean_name = re.sub('^[^/]+/', '', r.attrib['name']) excluded = False for g in globs: if fnmatch.fnmatch(clean_name, g): excluded = True break if not excluded: sys.stdout.write("NOT APPROVED: %s (%s): %s\n" % ( clean_name, r.attrib['name'], approvals[0].attrib['name'])) all_ok = False if not all_ok: sys.exit(1) print('OK') sys.exit(0) apache-datafusion-sqlparser-rs-0.62.0/dev/release/create-tarball.sh000077500000000000000000000111661517524037000252370ustar00rootroot00000000000000#!/bin/bash # # 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. # # Adapted from https://github.com/apache/datafusion/tree/master/dev/release/create-tarball.sh # This script creates a signed tarball in # dev/dist/apache-datafusion-sqlparser-rs--rc.tar.gz and uploads it to # the "dev" area of the dist.apache.datafusion repository and prepares an # email for sending to the dev@datafusion.apache.org list for a formal # vote. # # See release/README.md for full release instructions # # Requirements: # # 1. gpg setup for signing and have uploaded your public # signature to https://pgp.mit.edu/ # # 2. Logged into the apache svn server with the appropriate # credentials # # 3. Install the requests python package # # # Based in part on 02-source.sh from apache/arrow # set -e SOURCE_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" SOURCE_TOP_DIR="$(cd "${SOURCE_DIR}/../../" && pwd)" if [ "$#" -ne 2 ]; then echo "Usage: $0 " echo "ex. $0 0.52.0 2" exit fi if [[ -z "${GITHUB_TOKEN}" ]]; then echo "Please set personal github token through GITHUB_TOKEN environment variable" exit fi version=$1 rc=$2 tag="v${version}-rc${rc}" echo "Attempting to create ${tarball} from tag ${tag}" release_hash=$(cd "${SOURCE_TOP_DIR}" && git rev-list --max-count=1 ${tag}) release=apache-datafusion-sqlparser-rs-${version} distdir=${SOURCE_TOP_DIR}/dev/dist/${release}-rc${rc} tarname=${release}.tar.gz tarball=${distdir}/${tarname} url="https://dist.apache.org/repos/dist/dev/datafusion/${release}-rc${rc}" if [ -z "$release_hash" ]; then echo "Cannot continue: unknown git tag: ${tag}" fi echo "Draft email for dev@datafusion.apache.org mailing list" echo "" echo "---------------------------------------------------------" cat < containing the files in git at $release_hash # the files in the tarball are prefixed with {version} (e.g. 4.0.1) mkdir -p ${distdir} (cd "${SOURCE_TOP_DIR}" && git archive ${release_hash} --prefix ${release}/ | gzip > ${tarball}) echo "Running rat license checker on ${tarball}" ${SOURCE_DIR}/run-rat.sh ${tarball} echo "Signing tarball and creating checksums" gpg --armor --output ${tarball}.asc --detach-sig ${tarball} # create signing with relative path of tarball # so that they can be verified with a command such as # shasum --check apache-datafusion-sqlparser-rs-0.52.0-rc1.tar.gz.sha512 (cd ${distdir} && shasum -a 256 ${tarname}) > ${tarball}.sha256 (cd ${distdir} && shasum -a 512 ${tarname}) > ${tarball}.sha512 echo "Uploading to sqlparser-rs dist/dev to ${url}" svn co --depth=empty https://dist.apache.org/repos/dist/dev/datafusion ${SOURCE_TOP_DIR}/dev/dist svn add ${distdir} svn ci -m "Apache DataFusion ${version} ${rc}" ${distdir} apache-datafusion-sqlparser-rs-0.62.0/dev/release/generate-changelog.py000077500000000000000000000144671517524037000261210ustar00rootroot00000000000000#!/usr/bin/env python # 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. import argparse import sys from github import Github import os import re import subprocess def print_pulls(repo_name, title, pulls): if len(pulls) > 0: print("**{}:**".format(title)) 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() def generate_changelog(repo, repo_name, tag1, tag2, version): # get a list of commits between two tags print(f"Fetching list of commits between {tag1} and {tag2}", file=sys.stderr) comparison = repo.compare(tag1, tag2) # get the pull requests for these commits print("Fetching pull requests", file=sys.stderr) unique_pulls = [] all_pulls = [] for commit in comparison.commits: pulls = commit.get_pulls() for pull in pulls: # there can be multiple commits per PR if squash merge is not being used and # in this case we should get all the author names, but for now just pick one if pull.number not in unique_pulls: unique_pulls.append(pull.number) all_pulls.append((pull, commit)) # we split the pulls into categories breaking = [] bugs = [] docs = [] enhancements = [] performance = [] other = [] # categorize the pull requests based on GitHub labels print("Categorizing pull requests", file=sys.stderr) for (pull, commit) in all_pulls: # see if PR title uses Conventional Commits cc_type = '' cc_scope = '' cc_breaking = '' parts = re.findall(r'^([a-z]+)(\([a-z]+\))?(!)?:', pull.title) if len(parts) == 1: parts_tuple = parts[0] cc_type = parts_tuple[0] # fix, feat, docs, chore cc_scope = parts_tuple[1] # component within project cc_breaking = parts_tuple[2] == '!' labels = [label.name for label in pull.labels] if 'api change' in labels or cc_breaking: breaking.append((pull, commit)) elif 'bug' in labels or cc_type == 'fix': bugs.append((pull, commit)) elif 'performance' in labels or cc_type == 'perf': performance.append((pull, commit)) elif 'enhancement' in labels or cc_type == 'feat': enhancements.append((pull, commit)) elif 'documentation' in labels or cc_type == 'docs' or cc_type == 'doc': docs.append((pull, commit)) else: other.append((pull, commit)) # produce the changelog content print("Generating changelog content", file=sys.stderr) # ASF header print("""\n""") print(f"# sqlparser-rs {version} Changelog\n") # get the number of commits commit_count = subprocess.check_output(f"git log --pretty=oneline {tag1}..{tag2} | wc -l", shell=True, text=True).strip() # get number of contributors contributor_count = subprocess.check_output(f"git shortlog -sn {tag1}..{tag2} | wc -l", shell=True, text=True).strip() print(f"This release consists of {commit_count} commits from {contributor_count} contributors. " f"See credits at the end of this changelog for more information.\n") print_pulls(repo_name, "Breaking changes", breaking) print_pulls(repo_name, "Performance related", performance) print_pulls(repo_name, "Implemented enhancements", enhancements) print_pulls(repo_name, "Fixed bugs", bugs) print_pulls(repo_name, "Documentation updates", docs) print_pulls(repo_name, "Other", other) # show code contributions credits = subprocess.check_output(f"git shortlog -sn {tag1}..{tag2}", shell=True, text=True).rstrip() print("## Credits\n") print("Thank you to everyone who contributed to this release. Here is a breakdown of commits (PRs merged) " "per contributor.\n") print("```") print(credits) print("```\n") print("Thank you also to everyone who contributed in other ways such as filing issues, reviewing " "PRs, and providing feedback on this release.\n") def cli(args=None): """Process command line arguments.""" if not args: args = sys.argv[1:] parser = argparse.ArgumentParser() parser.add_argument("tag1", help="The previous commit or tag (e.g. 0.1.0)") parser.add_argument("tag2", help="The current commit or tag (e.g. HEAD)") parser.add_argument("version", help="The version number to include in the changelog") args = parser.parse_args() token = os.getenv("GITHUB_TOKEN") project = "apache/datafusion-sqlparser-rs" g = Github(token) repo = g.get_repo(project) generate_changelog(repo, project, args.tag1, args.tag2, args.version) if __name__ == "__main__": cli() apache-datafusion-sqlparser-rs-0.62.0/dev/release/rat_exclude_files.txt000066400000000000000000000002311517524037000262270ustar00rootroot00000000000000.tool-versions target/* **.gitignore rat.txt dev/release/rat_exclude_files.txt sqlparser_bench/img/flamegraph.svg **Cargo.lock filtered_rat.txt AGENTS.mdapache-datafusion-sqlparser-rs-0.62.0/dev/release/release-tarball.sh000077500000000000000000000046631517524037000254200ustar00rootroot00000000000000#!/bin/bash # # 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. # # Adapted from https://github.com/apache/arrow-rs/tree/master/dev/release/release-tarball.sh # This script copies a tarball from the "dev" area of the # dist.apache.datafusion repository to the "release" area # # This script should only be run after the release has been approved # by the Apache DataFusion PMC committee. # # See release/README.md for full release instructions # # Based in part on post-01-upload.sh from apache/arrow set -e set -u if [ "$#" -ne 2 ]; then echo "Usage: $0 " echo "ex. $0 0.52.0 2" exit fi version=$1 rc=$2 read -r -p "Proceed to release tarball for ${version}-rc${rc}? [y/N]: " answer answer=${answer:-no} if [ "${answer}" != "y" ]; then echo "Cancelled tarball release!" exit 1 fi tmp_dir=tmp-apache-datafusion-dist echo "Recreate temporary directory: ${tmp_dir}" rm -rf ${tmp_dir} mkdir -p ${tmp_dir} echo "Clone dev dist repository" svn \ co \ https://dist.apache.org/repos/dist/dev/datafusion/apache-datafusion-sqlparser-rs-${version}-rc${rc} \ ${tmp_dir}/dev echo "Clone release dist repository" svn co https://dist.apache.org/repos/dist/release/datafusion ${tmp_dir}/release echo "Copy ${version}-rc${rc} to release working copy" release_version=datafusion-sqlparser-rs-${version} mkdir -p ${tmp_dir}/release/${release_version} cp -r ${tmp_dir}/dev/* ${tmp_dir}/release/${release_version}/ svn add ${tmp_dir}/release/${release_version} echo "Commit release" svn ci -m "Apache DataFusion sqlparser-rs ${version}" ${tmp_dir}/release echo "Clean up" rm -rf ${tmp_dir} echo "Success! The release is available here:" echo " https://dist.apache.org/repos/dist/release/datafusion/${release_version}" apache-datafusion-sqlparser-rs-0.62.0/dev/release/run-rat.sh000077500000000000000000000027721517524037000237500ustar00rootroot00000000000000#!/bin/bash # # 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. # RAT_VERSION=0.13 # download apache rat if [ ! -f apache-rat-${RAT_VERSION}.jar ]; then curl -s https://repo1.maven.org/maven2/org/apache/rat/apache-rat/${RAT_VERSION}/apache-rat-${RAT_VERSION}.jar > apache-rat-${RAT_VERSION}.jar fi RAT="java -jar apache-rat-${RAT_VERSION}.jar -x " RELEASE_DIR=$(cd "$(dirname "$BASH_SOURCE")"; pwd) # generate the rat report $RAT $1 > rat.txt python $RELEASE_DIR/check-rat-report.py $RELEASE_DIR/rat_exclude_files.txt rat.txt > filtered_rat.txt cat filtered_rat.txt UNAPPROVED=`cat filtered_rat.txt | grep "NOT APPROVED" | wc -l` if [ "0" -eq "${UNAPPROVED}" ]; then echo "No unapproved licenses" else echo "${UNAPPROVED} unapproved licences. Check rat report: rat.txt" exit 1 fi apache-datafusion-sqlparser-rs-0.62.0/dev/release/verify-release-candidate.sh000077500000000000000000000077441517524037000272200ustar00rootroot00000000000000#!/bin/bash # # 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. # case $# in 2) VERSION="$1" RC_NUMBER="$2" ;; *) echo "Usage: $0 X.Y.Z RC_NUMBER" exit 1 ;; esac set -e set -x set -o pipefail SOURCE_DIR="$(cd "$(dirname "${BASH_SOURCE[0]:-$0}")" && pwd)" ARROW_DIR="$(dirname $(dirname ${SOURCE_DIR}))" ARROW_DIST_URL='https://dist.apache.org/repos/dist/dev/datafusion' download_dist_file() { curl \ --silent \ --show-error \ --fail \ --location \ --remote-name $ARROW_DIST_URL/$1 } download_rc_file() { download_dist_file apache-datafusion-sqlparser-rs-${VERSION}-rc${RC_NUMBER}/$1 } import_gpg_keys() { download_dist_file KEYS gpg --import KEYS } if type shasum >/dev/null 2>&1; then sha256_verify="shasum -a 256 -c" sha512_verify="shasum -a 512 -c" else sha256_verify="sha256sum -c" sha512_verify="sha512sum -c" fi fetch_archive() { local dist_name=$1 download_rc_file ${dist_name}.tar.gz download_rc_file ${dist_name}.tar.gz.asc download_rc_file ${dist_name}.tar.gz.sha256 download_rc_file ${dist_name}.tar.gz.sha512 verify_dir_artifact_signatures } verify_dir_artifact_signatures() { # verify the signature and the checksums of each artifact find . -name '*.asc' | while read sigfile; do artifact=${sigfile/.asc/} gpg --verify $sigfile $artifact || exit 1 # go into the directory because the checksum files contain only the # basename of the artifact pushd $(dirname $artifact) base_artifact=$(basename $artifact) ${sha256_verify} $base_artifact.sha256 || exit 1 ${sha512_verify} $base_artifact.sha512 || exit 1 popd done } setup_tempdir() { cleanup() { if [ "${TEST_SUCCESS}" = "yes" ]; then rm -fr "${ARROW_TMPDIR}" else echo "Failed to verify release candidate. See ${ARROW_TMPDIR} for details." fi } if [ -z "${ARROW_TMPDIR}" ]; then # clean up automatically if ARROW_TMPDIR is not defined ARROW_TMPDIR=$(mktemp -d -t "$1.XXXXX") trap cleanup EXIT else # don't clean up automatically mkdir -p "${ARROW_TMPDIR}" fi } test_source_distribution() { # install rust toolchain in a similar fashion like test-miniconda export RUSTUP_HOME=$PWD/test-rustup export CARGO_HOME=$PWD/test-rustup curl https://sh.rustup.rs -sSf | sh -s -- -y --no-modify-path export PATH=$RUSTUP_HOME/bin:$PATH source $RUSTUP_HOME/env # build and test rust # raises on any formatting errors rustup component add rustfmt --toolchain stable cargo fmt --all -- --check cargo build cargo test --all-features if ( find . -iname 'Cargo.toml' | xargs grep SNAPSHOT ); then echo "Cargo.toml version should not contain SNAPSHOT for releases" exit 1 fi # Can't test using dry-run because sqlparser depends on sqlparser_derive # see https://github.com/crate-ci/cargo-release/issues/691#issuecomment-2059866021 # Check that publish works # cargo publish --dry-run } TEST_SUCCESS=no setup_tempdir "datafusion-sqlparser-rs-${VERSION}" echo "Working in sandbox ${ARROW_TMPDIR}" cd ${ARROW_TMPDIR} dist_name="apache-datafusion-sqlparser-rs-${VERSION}" import_gpg_keys fetch_archive ${dist_name} tar xf ${dist_name}.tar.gz pushd ${dist_name} test_source_distribution popd TEST_SUCCESS=yes echo 'Release candidate looks good!' exit 0 apache-datafusion-sqlparser-rs-0.62.0/docs/000077500000000000000000000000001517524037000205435ustar00rootroot00000000000000apache-datafusion-sqlparser-rs-0.62.0/docs/benchmarking.md000066400000000000000000000020571517524037000235210ustar00rootroot00000000000000 # Benchmarking Run `cargo bench` in the project `sqlparser_bench` execute the queries. It will report results using the `criterion` library to perform the benchmarking. The bench project lives in another crate, to avoid the negative impact on building the `sqlparser` crate. apache-datafusion-sqlparser-rs-0.62.0/docs/custom_sql_parser.md000066400000000000000000000030561517524037000246360ustar00rootroot00000000000000 # Writing a Custom SQL Parser I have explored many different ways of building this library to make it easy to extend it for custom SQL dialects. Most of my attempts ended in failure but I have now found a workable solution. It is not without downsides but this seems to be the most pragmatic solution. The concept is simply to write a new parser that delegates to the ANSI parser so that as much as possible of the core functionality can be re-used. I also plan on building in specific support for custom data types, where a lambda function can be passed to the parser to parse data types. For an example of this, see the [DataFusion](https://github.com/apache/arrow-datafusion) project and its [query planner](https://github.com/apache/arrow-datafusion/tree/master/datafusion/sql). apache-datafusion-sqlparser-rs-0.62.0/docs/fuzzing.md000066400000000000000000000030301517524037000225550ustar00rootroot00000000000000 # Fuzzing ## Installing `honggfuzz` ``` cargo install honggfuzz ``` Install [dependencies](https://github.com/rust-fuzz/honggfuzz-rs#dependencies) for your system. ## Running the fuzzer Running the fuzzer is as easy as running in the `fuzz` directory. Choose a target: These are `[[bin]]` entries in `Cargo.toml`. List them with `cargo read-manifest | jq '.targets[].name'` from the `fuzz` directory. Run the fuzzer: ```shell cd fuzz cargo hfuzz run ``` After a panic is found, get a stack trace with: ```shell cargo hfuzz run-debug hfuzz_workspace//*.fuzz ``` For example, with the `fuzz_parse_sql` target: ```shell cargo hfuzz run fuzz_parse_sql cargo hfuzz run-debug fuzz_parse_sql hfuzz_workspace/fuzz_parse_sql/*.fuzz ``` apache-datafusion-sqlparser-rs-0.62.0/examples/000077500000000000000000000000001517524037000214315ustar00rootroot00000000000000apache-datafusion-sqlparser-rs-0.62.0/examples/cli.rs000066400000000000000000000075651517524037000225630ustar00rootroot00000000000000// 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. #![warn(clippy::all)] //! 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::*; use sqlparser::parser::Parser; fn main() { SimpleLogger::new().init().unwrap(); let filename = std::env::args().nth(1).expect( r#" No arguments provided! Usage: $ 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] "#, ); let dialect: Box = match std::env::args().nth(2).unwrap_or_default().as_ref() { "--ansi" => Box::new(AnsiDialect {}), "--bigquery" => Box::new(BigQueryDialect {}), "--postgres" => Box::new(PostgreSqlDialect {}), "--ms" => Box::new(MsSqlDialect {}), "--mysql" => Box::new(MySqlDialect {}), "--snowflake" => Box::new(SnowflakeDialect {}), "--hive" => Box::new(HiveDialect {}), "--redshift" => Box::new(RedshiftSqlDialect {}), "--clickhouse" => Box::new(ClickHouseDialect {}), "--duckdb" => Box::new(DuckDbDialect {}), "--sqlite" => Box::new(SQLiteDialect {}), "--oracle" => Box::new(OracleDialect {}), "--generic" | "" => Box::new(GenericDialect {}), 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)) }; let without_bom = if contents.chars().next().unwrap() as u64 != 0xfeff { contents.as_str() } else { let mut chars = contents.chars(); chars.next(); chars.as_str() }; let parse_result = Parser::parse_sql(&*dialect, without_bom); match parse_result { Ok(statements) => { println!( "Round-trip:\n'{}'", statements .iter() .map(std::string::ToString::to_string) .collect::>() .join("\n") ); if cfg!(feature = "json_example") { #[cfg(feature = "json_example")] { let serialized = serde_json::to_string_pretty(&statements).unwrap(); println!("Serialized as JSON:\n{serialized}"); } } else { println!("Parse results:\n{statements:#?}"); } std::process::exit(0); } Err(e) => { println!("Error during parsing: {e:?}"); std::process::exit(1); } } } apache-datafusion-sqlparser-rs-0.62.0/examples/parse_select.rs000066400000000000000000000022411517524037000244470ustar00rootroot00000000000000// 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. #![warn(clippy::all)] use sqlparser::dialect::GenericDialect; use sqlparser::parser::*; fn main() { let sql = "SELECT a, b, 123, myfunc(b) \ FROM table_1 \ WHERE a > b AND b < 100 \ ORDER BY a DESC, b"; let dialect = GenericDialect {}; let ast = Parser::parse_sql(&dialect, sql).unwrap(); println!("AST: {ast:?}"); } apache-datafusion-sqlparser-rs-0.62.0/fuzz/000077500000000000000000000000001517524037000206115ustar00rootroot00000000000000apache-datafusion-sqlparser-rs-0.62.0/fuzz/.gitignore000066400000000000000000000000441517524037000225770ustar00rootroot00000000000000corpus hfuzz_target hfuzz_workspace apache-datafusion-sqlparser-rs-0.62.0/fuzz/Cargo.toml000066400000000000000000000020641517524037000225430ustar00rootroot00000000000000# 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. [package] name = "fuzz" version = "0.1.0" edition = "2018" publish = false [dependencies] honggfuzz = "0.5.54" sqlparser = { path = ".." } # Prevent this from interfering with workspaces [workspace] members = ["."] [[bin]] name = "fuzz_parse_sql" path = "fuzz_targets/fuzz_parse_sql.rs" apache-datafusion-sqlparser-rs-0.62.0/fuzz/fuzz_targets/000077500000000000000000000000001517524037000233405ustar00rootroot00000000000000apache-datafusion-sqlparser-rs-0.62.0/fuzz/fuzz_targets/fuzz_parse_sql.rs000066400000000000000000000037521517524037000267640ustar00rootroot00000000000000// 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 honggfuzz::fuzz; use sqlparser::dialect::{ AnsiDialect, BigQueryDialect, ClickHouseDialect, DatabricksDialect, DuckDbDialect, GenericDialect, HiveDialect, MsSqlDialect, MySqlDialect, OracleDialect, PostgreSqlDialect, RedshiftSqlDialect, SQLiteDialect, SnowflakeDialect, }; use sqlparser::parser::Parser; fn main() { let dialects: Vec> = vec![ Box::new(AnsiDialect::default()), Box::new(BigQueryDialect::default()), Box::new(ClickHouseDialect::default()), Box::new(DatabricksDialect::default()), Box::new(DuckDbDialect::default()), Box::new(GenericDialect::default()), Box::new(HiveDialect::default()), Box::new(MsSqlDialect::default()), Box::new(MySqlDialect::default()), Box::new(OracleDialect::default()), Box::new(PostgreSqlDialect::default()), Box::new(RedshiftSqlDialect::default()), Box::new(SQLiteDialect::default()), Box::new(SnowflakeDialect::default()), ]; loop { fuzz!(|data: String| { for dialect in &dialects { let _ = Parser::parse_sql(dialect.as_ref(), &data); } }); } } apache-datafusion-sqlparser-rs-0.62.0/rustfmt.toml000066400000000000000000000015171517524037000222200ustar00rootroot00000000000000# 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. # We use rustfmt's default settings to format the source codeapache-datafusion-sqlparser-rs-0.62.0/sqlparser_bench/000077500000000000000000000000001517524037000227665ustar00rootroot00000000000000apache-datafusion-sqlparser-rs-0.62.0/sqlparser_bench/Cargo.toml000066400000000000000000000020701517524037000247150ustar00rootroot00000000000000# 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. [package] name = "sqlparser_bench" description = "Benchmarks for sqlparser" version = "0.1.0" authors = ["Dandandan "] edition = "2018" [dependencies] sqlparser = { path = "../" } [dev-dependencies] criterion = "0.8" [[bench]] name = "sqlparser_bench" harness = false apache-datafusion-sqlparser-rs-0.62.0/sqlparser_bench/README.md000066400000000000000000000025141517524037000242470ustar00rootroot00000000000000 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: ![flamegraph](img/flamegraph.svg) apache-datafusion-sqlparser-rs-0.62.0/sqlparser_bench/benches/000077500000000000000000000000001517524037000243755ustar00rootroot00000000000000apache-datafusion-sqlparser-rs-0.62.0/sqlparser_bench/benches/sqlparser_bench.rs000066400000000000000000000123551517524037000301240ustar00rootroot00000000000000// 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 criterion::{criterion_group, criterion_main, Criterion}; use sqlparser::dialect::GenericDialect; use sqlparser::keywords::Keyword; use sqlparser::parser::Parser; use sqlparser::tokenizer::{Span, Word}; 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"; group.bench_function("sqlparser::select", |b| { b.iter(|| Parser::parse_sql(&dialect, string).unwrap()); }); let with_query = " WITH derived AS ( SELECT MAX(a) AS max_a, COUNT(b) AS b_num, user_id FROM MY_TABLE GROUP BY user_id ) SELECT * FROM my_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::>() .join(", "); let tables = (0..1000) .map(|n| format!("TABLE_{n}")) .collect::>() .join(" CROSS JOIN "); let where_condition = (0..1000) .map(|n| format!("COL_{n} = {n}")) .collect::>() .join(" OR "); let order_condition = (0..1000) .map(|n| format!("COL_{n} DESC")) .collect::>() .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(); }); }); } /// Benchmark comparing `to_ident(&self)` vs `clone().into_ident(self)`. /// /// Both approaches have equivalent performance since the String clone dominates. /// `to_ident()` is preferred for clearer code (one method call vs two). fn word_to_ident(c: &mut Criterion) { let mut group = c.benchmark_group("word_to_ident"); // Create Word instances with varying identifier lengths let words: Vec = (0..100) .map(|i| Word { value: format!("identifier_name_with_number_{i}"), quote_style: None, keyword: Keyword::NoKeyword, }) .collect(); let span = Span::empty(); // clone().into_ident(): clones entire Word struct, then moves the String value group.bench_function("clone_into_ident_100x", |b| { b.iter(|| { for w in &words { std::hint::black_box(w.clone().into_ident(span)); } }); }); // to_ident(): clones only the String value directly into the Ident group.bench_function("to_ident_100x", |b| { b.iter(|| { for w in &words { std::hint::black_box(w.to_ident(span)); } }); }); group.finish(); } /// Benchmark parsing queries with many identifiers to show real-world impact fn parse_many_identifiers(c: &mut Criterion) { let mut group = c.benchmark_group("parse_identifiers"); let dialect = GenericDialect {}; // Query with many column references (identifiers) let many_columns = (0..100) .map(|n| format!("column_{n}")) .collect::>() .join(", "); let query = format!("SELECT {many_columns} FROM my_table"); group.bench_function("select_100_columns", |b| { b.iter(|| Parser::parse_sql(&dialect, std::hint::black_box(&query))); }); // Query with many table.column references let qualified_columns = (0..100) .map(|n| format!("t{}.column_{n}", n % 5)) .collect::>() .join(", "); let query_qualified = format!("SELECT {qualified_columns} FROM t0, t1, t2, t3, t4"); group.bench_function("select_100_qualified_columns", |b| { b.iter(|| Parser::parse_sql(&dialect, std::hint::black_box(&query_qualified))); }); group.finish(); } criterion_group!(benches, basic_queries, word_to_ident, parse_many_identifiers); criterion_main!(benches); apache-datafusion-sqlparser-rs-0.62.0/sqlparser_bench/img/000077500000000000000000000000001517524037000235425ustar00rootroot00000000000000apache-datafusion-sqlparser-rs-0.62.0/sqlparser_bench/img/flamegraph.svg000066400000000000000000060334111517524037000264010ustar00rootroot00000000000000Flame Graph Reset ZoomSearch sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<plotters_svg::svg::SVGBackend> (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<plotters_svg::svg::SVGBackend as core::ops::drop::Drop>::drop (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::kde::sweep_and_estimate (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<criterion::plot::plotters_backend::PlottersBackend as criterion::plot::Plotter>::abs_distributions (26 samples, 0.05%)sqlparser_bench-959bc5267970ca34`criterion::plot::plotters_backend::distributions::abs_distributions (25 samples, 0.05%)sqlparser_bench-959bc5267970ca34`<criterion::plot::plotters_backend::PlottersBackend as criterion::plot::Plotter>::pdf (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<criterion::html::Html as criterion::report::Report>::measurement_complete (38 samples, 0.08%)sqlparser_bench-959bc5267970ca34`criterion::estimate::build_estimates (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::analysis::estimates (7 samples, 0.01%)libsystem_malloc.dylib`_free (6 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (6 samples, 0.01%)libsystem_malloc.dylib`_free (38 samples, 0.08%)libsystem_malloc.dylib`_malloc_zone_malloc (5 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (32 samples, 0.07%)libsystem_malloc.dylib`_szone_free (13 samples, 0.03%)libsystem_malloc.dylib`small_free_list_add_ptr (12 samples, 0.03%)libsystem_malloc.dylib`small_free_list_remove_ptr (5 samples, 0.01%)libsystem_malloc.dylib`free_small (55 samples, 0.12%)libsystem_malloc.dylib`small_free_list_remove_ptr_no_clear (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<&T as core::fmt::Display>::fmt (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::query::OrderByExpr as core::fmt::Display>::fmt (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<str as core::fmt::Display>::fmt (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::pad (10 samples, 0.02%)libsystem_platform.dylib`_platform_memmove (25 samples, 0.05%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (21 samples, 0.04%)libsystem_platform.dylib`_platform_memmove (56 samples, 0.12%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$memcpy (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<&T as core::fmt::Display>::fmt (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Ident as core::fmt::Display>::fmt (11 samples, 0.02%)libsystem_platform.dylib`_platform_memmove (53 samples, 0.11%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Ident as core::fmt::Display>::fmt (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (164 samples, 0.34%)sqlparser_bench-959bc5267970ca34`core::fmt::write (128 samples, 0.27%)libdyld.dylib`tlv_get_addr (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`psm::stack_pointer (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rust_psm_stack_pointer (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt (58 samples, 0.12%)sqlparser_bench-959bc5267970ca34`stacker::remaining_stack (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::write_fmt (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::fmt::write (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`recursive::get_minimum_stack_size (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`recursive::get_stack_allocation_size (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::query::OrderByExpr as core::fmt::Display>::fmt (435 samples, 0.91%)sqlparser_bench-959bc5267970ca34`core::fmt::write (309 samples, 0.65%)sqlparser_bench-959bc5267970ca34`stacker::remaining_stack (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<str as core::fmt::Display>::fmt (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::pad (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::DisplaySeparated<T> as core::fmt::Display>::fmt (629 samples, 1.32%)sqlparser_bench-959bc5267970ca34`core::fmt::write (578 samples, 1.21%)sqlparser_bench-959bc5267970ca34`core::fmt::write (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::query::OrderBy as core::fmt::Display>::fmt (661 samples, 1.39%)sqlparser_bench-959bc5267970ca34`core::fmt::write (661 samples, 1.39%)sqlparser_bench-959bc5267970ca34`core::fmt::write (32 samples, 0.07%)sqlparser_bench-959bc5267970ca34`<&T as core::fmt::Display>::fmt (20 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::query::SelectItem as core::fmt::Display>::fmt (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<str as core::fmt::Display>::fmt (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::pad (14 samples, 0.03%)libsystem_platform.dylib`_platform_memmove (20 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<&T as core::fmt::Display>::fmt (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::query::Join as core::fmt::Display>::fmt (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<&T as core::fmt::Display>::fmt (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<<sqlparser::ast::query::Join as core::fmt::Display>::fmt::suffix::Suffix as core::fmt::Display>::fmt (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (39 samples, 0.08%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::query::TableFactor as core::fmt::Display>::fmt (20 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<str as core::fmt::Display>::fmt (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::pad (7 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (77 samples, 0.16%)sqlparser_bench-959bc5267970ca34`<<sqlparser::ast::query::Join as core::fmt::Display>::fmt::suffix::Suffix as core::fmt::Display>::fmt (26 samples, 0.05%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (32 samples, 0.07%)sqlparser_bench-959bc5267970ca34`<&T as core::fmt::Display>::fmt (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::DisplaySeparated<T> as core::fmt::Display>::fmt (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<&T as core::fmt::Display>::fmt (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<str as core::fmt::Display>::fmt (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::pad (23 samples, 0.05%)libsystem_platform.dylib`_platform_memmove (39 samples, 0.08%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (22 samples, 0.05%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Ident as core::fmt::Display>::fmt (27 samples, 0.06%)sqlparser_bench-959bc5267970ca34`<str as core::fmt::Display>::fmt (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$memcpy (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::pad (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::DisplaySeparated<T> as core::fmt::Display>::fmt (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::fmt::write (192 samples, 0.40%)sqlparser_bench-959bc5267970ca34`<&T as core::fmt::Display>::fmt (347 samples, 0.73%)sqlparser_bench-959bc5267970ca34`core::fmt::write (321 samples, 0.67%)sqlparser_bench-959bc5267970ca34`core::fmt::write (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::query::TableFactor as core::fmt::Display>::fmt (473 samples, 0.99%)sqlparser_bench-959bc5267970ca34`core::fmt::write (401 samples, 0.84%)sqlparser_bench-959bc5267970ca34`core::fmt::write (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<str as core::fmt::Display>::fmt (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$memcpy (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::pad (20 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::query::Join as core::fmt::Display>::fmt (859 samples, 1.80%)s..sqlparser_bench-959bc5267970ca34`core::fmt::write (753 samples, 1.58%)sqlparser_bench-959bc5267970ca34`core::fmt::write (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<&T as core::fmt::Display>::fmt (931 samples, 1.96%)s..sqlparser_bench-959bc5267970ca34`core::fmt::write (902 samples, 1.89%)s..sqlparser_bench-959bc5267970ca34`core::fmt::write (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<&T as core::fmt::Display>::fmt (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (11 samples, 0.02%)libdyld.dylib`tlv_get_addr (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`psm::stack_pointer (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rust_psm_stack_pointer (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<&T as core::fmt::Display>::fmt (53 samples, 0.11%)sqlparser_bench-959bc5267970ca34`stacker::remaining_stack (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<&T as core::fmt::Display>::fmt (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Function as core::fmt::Display>::fmt (24 samples, 0.05%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::FunctionArguments as core::fmt::Display>::fmt (41 samples, 0.09%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::ObjectName as core::fmt::Display>::fmt (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (28 samples, 0.06%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::FunctionArgumentList as core::fmt::Display>::fmt (8 samples, 0.02%)libsystem_platform.dylib`_platform_memmove (35 samples, 0.07%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (26 samples, 0.05%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::DisplaySeparated<T> as core::fmt::Display>::fmt (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<&T as core::fmt::Display>::fmt (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<str as core::fmt::Display>::fmt (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::pad (9 samples, 0.02%)libsystem_platform.dylib`_platform_memmove (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<&T as core::fmt::Display>::fmt (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::FunctionArgExpr as core::fmt::Display>::fmt (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<&T as core::fmt::Display>::fmt (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (10 samples, 0.02%)libdyld.dylib`tlv_get_addr (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`psm::stack_pointer (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rust_psm_stack_pointer (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<&T as core::fmt::Display>::fmt (63 samples, 0.13%)sqlparser_bench-959bc5267970ca34`stacker::remaining_stack (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<&T as core::fmt::Display>::fmt (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Ident as core::fmt::Display>::fmt (7 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (65 samples, 0.14%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Ident as core::fmt::Display>::fmt (34 samples, 0.07%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (231 samples, 0.49%)sqlparser_bench-959bc5267970ca34`core::fmt::write (188 samples, 0.39%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::write_str (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::write_fmt (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::fmt::write (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`recursive::get_minimum_stack_size (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`recursive::get_stack_allocation_size (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::FunctionArgExpr as core::fmt::Display>::fmt (450 samples, 0.95%)sqlparser_bench-959bc5267970ca34`core::fmt::write (408 samples, 0.86%)sqlparser_bench-959bc5267970ca34`stacker::remaining_stack (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::FunctionArg as core::fmt::Display>::fmt (528 samples, 1.11%)sqlparser_bench-959bc5267970ca34`core::fmt::write (500 samples, 1.05%)sqlparser_bench-959bc5267970ca34`core::fmt::write (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<str as core::fmt::Display>::fmt (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::pad (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::DisplaySeparated<T> as core::fmt::Display>::fmt (711 samples, 1.49%)sqlparser_bench-959bc5267970ca34`core::fmt::write (645 samples, 1.35%)sqlparser_bench-959bc5267970ca34`core::fmt::write (20 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::FunctionArgumentList as core::fmt::Display>::fmt (805 samples, 1.69%)sqlparser_bench-959bc5267970ca34`core::fmt::write (772 samples, 1.62%)sqlparser_bench-959bc5267970ca34`core::fmt::write (30 samples, 0.06%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$memcpy (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::FunctionArguments as core::fmt::Display>::fmt (1,024 samples, 2.15%)s..sqlparser_bench-959bc5267970ca34`core::fmt::write (972 samples, 2.04%)s..sqlparser_bench-959bc5267970ca34`core::fmt::write (23 samples, 0.05%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::DisplaySeparated<T> as core::fmt::Display>::fmt (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<&T as core::fmt::Display>::fmt (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (37 samples, 0.08%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Ident as core::fmt::Display>::fmt (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<str as core::fmt::Display>::fmt (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::pad (18 samples, 0.04%)libsystem_platform.dylib`_platform_memmove (50 samples, 0.11%)libsystem_malloc.dylib`szone_realloc (5 samples, 0.01%)libsystem_malloc.dylib`_malloc_zone_realloc (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (29 samples, 0.06%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVecInner<A>::reserve::do_reserve_and_handle (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (8 samples, 0.02%)libsystem_malloc.dylib`_realloc (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Ident as core::fmt::Display>::fmt (40 samples, 0.08%)sqlparser_bench-959bc5267970ca34`<str as core::fmt::Display>::fmt (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$memcpy (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::pad (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::DisplaySeparated<T> as core::fmt::Display>::fmt (321 samples, 0.67%)sqlparser_bench-959bc5267970ca34`core::fmt::write (219 samples, 0.46%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::write_str (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::ObjectName as core::fmt::Display>::fmt (425 samples, 0.89%)sqlparser_bench-959bc5267970ca34`core::fmt::write (390 samples, 0.82%)sqlparser_bench-959bc5267970ca34`core::fmt::write (26 samples, 0.05%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Function as core::fmt::Display>::fmt (1,627 samples, 3.42%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,551 samples, 3.26%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (43 samples, 0.09%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,728 samples, 3.63%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,678 samples, 3.52%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`core::fmt::write (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`recursive::get_minimum_stack_size (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`recursive::get_stack_allocation_size (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::query::SelectItem as core::fmt::Display>::fmt (1,910 samples, 4.01%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,868 samples, 3.92%)sqlp..sqlparser_bench-959bc5267970ca34`stacker::remaining_stack (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<str as core::fmt::Display>::fmt (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::pad (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::DisplaySeparated<T> as core::fmt::Display>::fmt (3,038 samples, 6.38%)sqlparse..sqlparser_bench-959bc5267970ca34`core::fmt::write (2,973 samples, 6.24%)sqlparse..sqlparser_bench-959bc5267970ca34`core::fmt::write (26 samples, 0.05%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::fmt::write (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::fmt::write (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`core::fmt::write (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`core::fmt::write (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`core::fmt::write (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`core::fmt::write (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (20 samples, 0.04%)sqlparser_bench-959bc5267970ca34`core::fmt::write (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (24 samples, 0.05%)sqlparser_bench-959bc5267970ca34`core::fmt::write (24 samples, 0.05%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (24 samples, 0.05%)sqlparser_bench-959bc5267970ca34`core::fmt::write (23 samples, 0.05%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (28 samples, 0.06%)sqlparser_bench-959bc5267970ca34`core::fmt::write (27 samples, 0.06%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (30 samples, 0.06%)sqlparser_bench-959bc5267970ca34`core::fmt::write (30 samples, 0.06%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (32 samples, 0.07%)sqlparser_bench-959bc5267970ca34`core::fmt::write (32 samples, 0.07%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (35 samples, 0.07%)sqlparser_bench-959bc5267970ca34`core::fmt::write (35 samples, 0.07%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (35 samples, 0.07%)sqlparser_bench-959bc5267970ca34`core::fmt::write (35 samples, 0.07%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (37 samples, 0.08%)sqlparser_bench-959bc5267970ca34`core::fmt::write (37 samples, 0.08%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (44 samples, 0.09%)sqlparser_bench-959bc5267970ca34`core::fmt::write (42 samples, 0.09%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (40 samples, 0.08%)sqlparser_bench-959bc5267970ca34`core::fmt::write (40 samples, 0.08%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (39 samples, 0.08%)sqlparser_bench-959bc5267970ca34`core::fmt::write (39 samples, 0.08%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (38 samples, 0.08%)sqlparser_bench-959bc5267970ca34`core::fmt::write (38 samples, 0.08%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (48 samples, 0.10%)sqlparser_bench-959bc5267970ca34`core::fmt::write (47 samples, 0.10%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (47 samples, 0.10%)sqlparser_bench-959bc5267970ca34`core::fmt::write (46 samples, 0.10%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (51 samples, 0.11%)sqlparser_bench-959bc5267970ca34`core::fmt::write (51 samples, 0.11%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (55 samples, 0.12%)sqlparser_bench-959bc5267970ca34`core::fmt::write (54 samples, 0.11%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (59 samples, 0.12%)sqlparser_bench-959bc5267970ca34`core::fmt::write (59 samples, 0.12%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (61 samples, 0.13%)sqlparser_bench-959bc5267970ca34`core::fmt::write (61 samples, 0.13%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (61 samples, 0.13%)sqlparser_bench-959bc5267970ca34`core::fmt::write (61 samples, 0.13%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (63 samples, 0.13%)sqlparser_bench-959bc5267970ca34`core::fmt::write (62 samples, 0.13%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (65 samples, 0.14%)sqlparser_bench-959bc5267970ca34`core::fmt::write (65 samples, 0.14%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (67 samples, 0.14%)sqlparser_bench-959bc5267970ca34`core::fmt::write (67 samples, 0.14%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (68 samples, 0.14%)sqlparser_bench-959bc5267970ca34`core::fmt::write (68 samples, 0.14%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (72 samples, 0.15%)sqlparser_bench-959bc5267970ca34`core::fmt::write (71 samples, 0.15%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (79 samples, 0.17%)sqlparser_bench-959bc5267970ca34`core::fmt::write (79 samples, 0.17%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (78 samples, 0.16%)sqlparser_bench-959bc5267970ca34`core::fmt::write (78 samples, 0.16%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (75 samples, 0.16%)sqlparser_bench-959bc5267970ca34`core::fmt::write (75 samples, 0.16%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (74 samples, 0.16%)sqlparser_bench-959bc5267970ca34`core::fmt::write (74 samples, 0.16%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (82 samples, 0.17%)sqlparser_bench-959bc5267970ca34`core::fmt::write (82 samples, 0.17%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (81 samples, 0.17%)sqlparser_bench-959bc5267970ca34`core::fmt::write (81 samples, 0.17%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::query::Query as core::fmt::Display>::fmt (3,806 samples, 7.99%)sqlparser_b..sqlparser_bench-959bc5267970ca34`core::fmt::write (3,806 samples, 7.99%)sqlparser_b..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::query::SetExpr as core::fmt::Display>::fmt (3,145 samples, 6.60%)sqlparser..sqlparser_bench-959bc5267970ca34`core::fmt::write (3,145 samples, 6.60%)sqlparser..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::query::Select as core::fmt::Display>::fmt (3,144 samples, 6.60%)sqlparser..sqlparser_bench-959bc5267970ca34`core::fmt::write (3,143 samples, 6.60%)sqlparser..sqlparser_bench-959bc5267970ca34`core::fmt::write (22 samples, 0.05%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Statement as core::fmt::Display>::fmt (3,809 samples, 8.00%)sqlparser_b..sqlparser_bench-959bc5267970ca34`core::fmt::write (3,808 samples, 8.00%)sqlparser_b..sqlparser_bench-959bc5267970ca34`DYLD-STUB$$free (32 samples, 0.07%)libsystem_malloc.dylib`_free (5 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (7 samples, 0.01%)libsystem_malloc.dylib`_free (19 samples, 0.04%)libsystem_malloc.dylib`_nanov2_free (17 samples, 0.04%)libsystem_malloc.dylib`_szone_free (12 samples, 0.03%)libsystem_malloc.dylib`small_free_list_add_ptr (18 samples, 0.04%)libsystem_malloc.dylib`small_free_list_remove_ptr (8 samples, 0.02%)libsystem_malloc.dylib`free_small (83 samples, 0.17%)libsystem_malloc.dylib`small_free_list_remove_ptr_no_clear (29 samples, 0.06%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$free (11 samples, 0.02%)libsystem_malloc.dylib`_nanov2_free (7 samples, 0.01%)libsystem_malloc.dylib`_free (7 samples, 0.01%)libsystem_malloc.dylib`free_small (10 samples, 0.02%)libsystem_malloc.dylib`_nanov2_free (11 samples, 0.02%)libsystem_malloc.dylib`free_small (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<alloc::vec::Vec<T,A> as core::ops::drop::Drop>::drop (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::query::TableFactor> (11 samples, 0.02%)libsystem_malloc.dylib`_nanov2_free (13 samples, 0.03%)libsystem_malloc.dylib`free_small (12 samples, 0.03%)libsystem_malloc.dylib`small_free_list_add_ptr (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::query::Cte> (128 samples, 0.27%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::query::Query> (112 samples, 0.24%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::query::SetExpr> (91 samples, 0.19%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::query::SelectItem> (46 samples, 0.10%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Function> (40 samples, 0.08%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::FunctionArgumentList> (17 samples, 0.04%)libsystem_malloc.dylib`_nanov2_free (12 samples, 0.03%)libsystem_malloc.dylib`free_medium (39 samples, 0.08%)libsystem_kernel.dylib`madvise (39 samples, 0.08%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::query::OrderBy> (58 samples, 0.12%)libsystem_malloc.dylib`nanov2_madvise_block (5 samples, 0.01%)libsystem_malloc.dylib`nanov2_madvise_block_locked (5 samples, 0.01%)libsystem_kernel.dylib`madvise (5 samples, 0.01%)libsystem_malloc.dylib`_free (16 samples, 0.03%)libsystem_malloc.dylib`_nanov2_free (16 samples, 0.03%)libsystem_malloc.dylib`_szone_free (12 samples, 0.03%)libsystem_malloc.dylib`free_medium (18 samples, 0.04%)libsystem_kernel.dylib`madvise (18 samples, 0.04%)libsystem_malloc.dylib`small_free_list_add_ptr (10 samples, 0.02%)libsystem_malloc.dylib`small_free_list_find_by_ptr (9 samples, 0.02%)libsystem_malloc.dylib`free_small (48 samples, 0.10%)libsystem_malloc.dylib`small_free_list_remove_ptr_no_clear (8 samples, 0.02%)libsystem_malloc.dylib`tiny_free_list_add_ptr (8 samples, 0.02%)libsystem_malloc.dylib`free_tiny (44 samples, 0.09%)libsystem_malloc.dylib`tiny_free_no_lock (30 samples, 0.06%)libsystem_malloc.dylib`tiny_free_list_remove_ptr (10 samples, 0.02%)libsystem_malloc.dylib`_free (10 samples, 0.02%)libsystem_malloc.dylib`_nanov2_free (10 samples, 0.02%)libsystem_malloc.dylib`_nanov2_free (52 samples, 0.11%)libsystem_malloc.dylib`nanov2_madvise_block (13 samples, 0.03%)libsystem_malloc.dylib`nanov2_madvise_block_locked (13 samples, 0.03%)libsystem_kernel.dylib`madvise (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<alloc::vec::Vec<T,A> as core::ops::drop::Drop>::drop (131 samples, 0.28%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::query::TableFactor> (96 samples, 0.20%)libsystem_platform.dylib`_platform_memset (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$free (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (7 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (7 samples, 0.01%)libsystem_malloc.dylib`tiny_free_list_add_ptr (5 samples, 0.01%)libsystem_malloc.dylib`free_tiny (28 samples, 0.06%)libsystem_malloc.dylib`tiny_free_no_lock (16 samples, 0.03%)libsystem_malloc.dylib`_nanov2_free (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (70 samples, 0.15%)libsystem_malloc.dylib`_free (5 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (13 samples, 0.03%)libsystem_malloc.dylib`nanov2_madvise_block (6 samples, 0.01%)libsystem_malloc.dylib`nanov2_madvise_block_locked (6 samples, 0.01%)libsystem_kernel.dylib`madvise (6 samples, 0.01%)libsystem_platform.dylib`_platform_memset (5 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (7 samples, 0.01%)libsystem_malloc.dylib`small_free_list_add_ptr (12 samples, 0.03%)libsystem_malloc.dylib`free_small (38 samples, 0.08%)libsystem_malloc.dylib`small_free_list_remove_ptr_no_clear (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Function> (95 samples, 0.20%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::FunctionArgumentList> (54 samples, 0.11%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::query::SetExpr> (510 samples, 1.07%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::query::Query>> (873 samples, 1.83%)s..sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::query::Query> (854 samples, 1.79%)s..sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::tokenizer::Token> (175 samples, 0.37%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::tokenizer::Whitespace> (57 samples, 0.12%)libsystem_malloc.dylib`_nanov2_free (123 samples, 0.26%)libsystem_malloc.dylib`free_medium (62 samples, 0.13%)libsystem_kernel.dylib`madvise (62 samples, 0.13%)libsystem_malloc.dylib`free_small (5 samples, 0.01%)libsystem_malloc.dylib`nanov2_madvise_block (5 samples, 0.01%)libsystem_malloc.dylib`nanov2_madvise_block_locked (5 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (83 samples, 0.17%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (5 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (5 samples, 0.01%)libsystem_malloc.dylib`nanov2_malloc_type (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (17 samples, 0.04%)libsystem_malloc.dylib`_malloc_zone_malloc (5 samples, 0.01%)libsystem_malloc.dylib`small_free_list_add_ptr (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVec<T,A>::grow_one (67 samples, 0.14%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (48 samples, 0.10%)libsystem_malloc.dylib`szone_malloc_should_clear (31 samples, 0.07%)libsystem_malloc.dylib`small_malloc_should_clear (25 samples, 0.05%)libsystem_malloc.dylib`small_malloc_from_free_list (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::tokenizer::Token> (5 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (9 samples, 0.02%)libsystem_platform.dylib`_platform_memmove (31 samples, 0.07%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_keyword (12 samples, 0.03%)libsystem_malloc.dylib`_malloc_zone_malloc (7 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (154 samples, 0.32%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (6 samples, 0.01%)libsystem_malloc.dylib`small_free_list_add_ptr (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`alloc::alloc::exchange_malloc (48 samples, 0.10%)libsystem_malloc.dylib`szone_malloc_should_clear (48 samples, 0.10%)libsystem_malloc.dylib`small_malloc_should_clear (36 samples, 0.08%)libsystem_malloc.dylib`small_malloc_from_free_list (32 samples, 0.07%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVec<T,A>::grow_one (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (8 samples, 0.02%)libsystem_malloc.dylib`szone_malloc_should_clear (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::tokenizer::Token> (5 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::expect_token (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_identifier (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_keyword (7 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (23 samples, 0.05%)sqlparser_bench-959bc5267970ca34`alloc::alloc::exchange_malloc (11 samples, 0.02%)libsystem_malloc.dylib`szone_malloc_should_clear (11 samples, 0.02%)libsystem_malloc.dylib`small_malloc_should_clear (8 samples, 0.02%)libsystem_malloc.dylib`small_malloc_from_free_list (7 samples, 0.01%)libsystem_malloc.dylib`szone_malloc_should_clear (5 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (16 samples, 0.03%)libsystem_platform.dylib`_platform_memmove (23 samples, 0.05%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::expect_keyword (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_all_or_distinct (9 samples, 0.02%)libsystem_platform.dylib`_platform_memmove (27 samples, 0.06%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVec<T,A>::grow_one (20 samples, 0.04%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (14 samples, 0.03%)libsystem_malloc.dylib`szone_malloc_should_clear (6 samples, 0.01%)libsystem_malloc.dylib`_free (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (13 samples, 0.03%)libsystem_malloc.dylib`nanov2_malloc_type (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (22 samples, 0.05%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_optional_alias (41 samples, 0.09%)libsystem_malloc.dylib`_nanov2_free (5 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (8 samples, 0.02%)libsystem_malloc.dylib`_malloc_zone_malloc (8 samples, 0.02%)libsystem_platform.dylib`_platform_memmove (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (7 samples, 0.01%)libsystem_malloc.dylib`nanov2_malloc_type (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (28 samples, 0.06%)libsystem_malloc.dylib`_free (5 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (9 samples, 0.02%)libsystem_platform.dylib`_platform_memmove (26 samples, 0.05%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$free (5 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::dialect::Dialect::get_next_precedence_default (26 samples, 0.05%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::peek_token (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_expr_prefix_by_unreserved_word (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_keyword (9 samples, 0.02%)libsystem_malloc.dylib`_free (5 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (11 samples, 0.02%)libsystem_platform.dylib`_platform_memmove (13 samples, 0.03%)libsystem_platform.dylib`_platform_memmove (9 samples, 0.02%)libsystem_malloc.dylib`nanov2_pointer_size (6 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (12 samples, 0.03%)libsystem_malloc.dylib`nanov2_realloc (25 samples, 0.05%)libsystem_malloc.dylib`nanov2_malloc (10 samples, 0.02%)libsystem_malloc.dylib`_malloc_zone_realloc (47 samples, 0.10%)libsystem_platform.dylib`_platform_memmove (6 samples, 0.01%)libsystem_malloc.dylib`_realloc (50 samples, 0.11%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVecInner<A>::reserve::do_reserve_and_handle (71 samples, 0.15%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (62 samples, 0.13%)libsystem_malloc.dylib`nanov2_size (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (76 samples, 0.16%)sqlparser_bench-959bc5267970ca34`alloc::fmt::format::format_inner (115 samples, 0.24%)sqlparser_bench-959bc5267970ca34`core::fmt::write (109 samples, 0.23%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Location as core::fmt::Display>::fmt (106 samples, 0.22%)sqlparser_bench-959bc5267970ca34`core::fmt::write (104 samples, 0.22%)sqlparser_bench-959bc5267970ca34`core::fmt::num::imp::_<impl core::fmt::Display for u64>::fmt (7 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::data_type::DataType> (28 samples, 0.06%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVec<T,A>::grow_one (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (16 samples, 0.03%)libsystem_malloc.dylib`nanov2_malloc_type (16 samples, 0.03%)libsystem_malloc.dylib`_nanov2_free (7 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_object_name (81 samples, 0.17%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_identifier (46 samples, 0.10%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (16 samples, 0.03%)libsystem_malloc.dylib`_nanov2_free (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVecInner<A>::reserve::do_reserve_and_handle (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (5 samples, 0.01%)libsystem_malloc.dylib`nanov2_malloc_type (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_optional_type_modifiers (47 samples, 0.10%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_data_type_helper (158 samples, 0.33%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_data_type (168 samples, 0.35%)libsystem_malloc.dylib`nanov2_malloc_type (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_compound_field_access (25 samples, 0.05%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::expect_token (5 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (5 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVec<T,A>::grow_one (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (14 samples, 0.03%)libsystem_malloc.dylib`szone_malloc_should_clear (14 samples, 0.03%)libsystem_malloc.dylib`small_malloc_should_clear (11 samples, 0.02%)libsystem_malloc.dylib`small_malloc_from_free_list (9 samples, 0.02%)libsystem_malloc.dylib`_nanov2_free (5 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVecInner<A>::reserve::do_reserve_and_handle (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (13 samples, 0.03%)libsystem_malloc.dylib`_nanov2_free (6 samples, 0.01%)libsystem_malloc.dylib`nanov2_realloc (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVecInner<A>::reserve::do_reserve_and_handle (26 samples, 0.05%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (23 samples, 0.05%)libsystem_malloc.dylib`_realloc (21 samples, 0.04%)libsystem_malloc.dylib`_malloc_zone_realloc (20 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (29 samples, 0.06%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Location as core::fmt::Display>::fmt (54 samples, 0.11%)sqlparser_bench-959bc5267970ca34`core::fmt::write (53 samples, 0.11%)sqlparser_bench-959bc5267970ca34`core::fmt::num::imp::_<impl core::fmt::Display for u64>::fmt (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`alloc::fmt::format::format_inner (119 samples, 0.25%)sqlparser_bench-959bc5267970ca34`core::fmt::write (105 samples, 0.22%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_function_named_arg_operator (134 samples, 0.28%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_identifier (19 samples, 0.04%)libsystem_malloc.dylib`_nanov2_free (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (9 samples, 0.02%)libsystem_platform.dylib`_platform_memmove (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`sqlparser::dialect::Dialect::get_next_precedence_default (5 samples, 0.01%)libsystem_malloc.dylib`_free (5 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (5 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (9 samples, 0.02%)libsystem_malloc.dylib`nanov2_realloc (24 samples, 0.05%)libsystem_malloc.dylib`nanov2_malloc (10 samples, 0.02%)libsystem_malloc.dylib`_malloc_zone_realloc (34 samples, 0.07%)libsystem_malloc.dylib`_realloc (40 samples, 0.08%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (48 samples, 0.10%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVecInner<A>::reserve::do_reserve_and_handle (46 samples, 0.10%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (44 samples, 0.09%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Location as core::fmt::Display>::fmt (69 samples, 0.14%)sqlparser_bench-959bc5267970ca34`core::fmt::write (69 samples, 0.14%)sqlparser_bench-959bc5267970ca34`core::fmt::num::imp::_<impl core::fmt::Display for u64>::fmt (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`alloc::fmt::format::format_inner (80 samples, 0.17%)sqlparser_bench-959bc5267970ca34`core::fmt::write (77 samples, 0.16%)libsystem_malloc.dylib`_nanov2_free (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::data_type::DataType> (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVec<T,A>::grow_one (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_object_name (36 samples, 0.08%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_identifier (27 samples, 0.06%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_data_type_helper (44 samples, 0.09%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_data_type (48 samples, 0.10%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (8 samples, 0.02%)libsystem_malloc.dylib`nanov2_malloc_type (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_expr_prefix_by_unreserved_word (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::try_parse (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_prefix (198 samples, 0.42%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_function_args (436 samples, 0.92%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_wildcard_expr (264 samples, 0.55%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_subexpr (241 samples, 0.51%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_comma_separated_with_trailing_commas (480 samples, 1.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_function_argument_list (541 samples, 1.14%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_function_call (564 samples, 1.18%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_expr_prefix_by_unreserved_word (641 samples, 1.35%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_prefix (1,035 samples, 2.17%)s..sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_select_item (1,271 samples, 2.67%)sq..sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_wildcard_expr (1,200 samples, 2.52%)sq..sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_subexpr (1,148 samples, 2.41%)sq..libsystem_platform.dylib`_platform_memmove (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_keyword (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_object_name (24 samples, 0.05%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_identifier (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_optional_table_alias (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_optional_alias (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::peek_token (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_table_factor (90 samples, 0.19%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::peek_tokens (28 samples, 0.06%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_comma_separated_with_trailing_commas (1,454 samples, 3.05%)sql..sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_table_and_joins (122 samples, 0.26%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVec<T,A>::grow_one (8 samples, 0.02%)libsystem_platform.dylib`_platform_memmove (12 samples, 0.03%)libsystem_malloc.dylib`nanov2_realloc (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (22 samples, 0.05%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVecInner<A>::reserve::do_reserve_and_handle (22 samples, 0.05%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (18 samples, 0.04%)libsystem_malloc.dylib`_realloc (11 samples, 0.02%)libsystem_malloc.dylib`_malloc_zone_realloc (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`alloc::fmt::format::format_inner (33 samples, 0.07%)sqlparser_bench-959bc5267970ca34`core::fmt::write (30 samples, 0.06%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Location as core::fmt::Display>::fmt (30 samples, 0.06%)sqlparser_bench-959bc5267970ca34`core::fmt::write (29 samples, 0.06%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::data_type::DataType> (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_object_name (24 samples, 0.05%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_identifier (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_data_type (33 samples, 0.07%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_data_type_helper (32 samples, 0.07%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_expr_prefix_by_unreserved_word (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_prefix (106 samples, 0.22%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_optional_group_by (154 samples, 0.32%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_subexpr (135 samples, 0.28%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_query_body (1,727 samples, 3.63%)sqlp..sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_select (1,681 samples, 3.53%)sql..sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_cte (1,854 samples, 3.89%)sqlp..sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_query (1,798 samples, 3.78%)sqlp..libsystem_platform.dylib`_platform_memmove (81 samples, 0.17%)libsystem_platform.dylib`_platform_memmove (18 samples, 0.04%)libsystem_malloc.dylib`_malloc_zone_realloc (8 samples, 0.02%)libsystem_platform.dylib`_platform_memmove (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVec<T,A>::grow_one (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (10 samples, 0.02%)libsystem_malloc.dylib`_realloc (10 samples, 0.02%)libsystem_platform.dylib`_platform_memmove (5 samples, 0.01%)libsystem_malloc.dylib`_free (6 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (20 samples, 0.04%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$memcpy (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (6 samples, 0.01%)libsystem_malloc.dylib`nanov2_malloc_type (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::dialect::Dialect::get_next_precedence_default (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::peek_token (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (12 samples, 0.03%)libsystem_malloc.dylib`_free (7 samples, 0.01%)libsystem_malloc.dylib`_malloc_zone_malloc (7 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (7 samples, 0.01%)libsystem_malloc.dylib`nanov2_malloc_type (6 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (5 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (11 samples, 0.02%)libsystem_malloc.dylib`nanov2_malloc (9 samples, 0.02%)libsystem_malloc.dylib`nanov2_realloc (26 samples, 0.05%)libsystem_malloc.dylib`_realloc (49 samples, 0.10%)libsystem_malloc.dylib`_malloc_zone_realloc (46 samples, 0.10%)libsystem_platform.dylib`_platform_memmove (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (64 samples, 0.13%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVecInner<A>::reserve::do_reserve_and_handle (60 samples, 0.13%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (54 samples, 0.11%)libsystem_platform.dylib`_platform_memmove (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`alloc::fmt::format::format_inner (106 samples, 0.22%)sqlparser_bench-959bc5267970ca34`core::fmt::write (99 samples, 0.21%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Location as core::fmt::Display>::fmt (92 samples, 0.19%)sqlparser_bench-959bc5267970ca34`core::fmt::write (90 samples, 0.19%)sqlparser_bench-959bc5267970ca34`core::fmt::num::imp::_<impl core::fmt::Display for u64>::fmt (13 samples, 0.03%)libsystem_malloc.dylib`_nanov2_free (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::data_type::DataType> (10 samples, 0.02%)libsystem_platform.dylib`_platform_memmove (7 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_object_name (58 samples, 0.12%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_identifier (45 samples, 0.09%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_data_type (73 samples, 0.15%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_data_type_helper (71 samples, 0.15%)libsystem_platform.dylib`_platform_memmove (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_expr_prefix_by_unreserved_word (29 samples, 0.06%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_prefix (277 samples, 0.58%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::try_parse (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_order_by_expr (357 samples, 0.75%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_subexpr (343 samples, 0.72%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_optional_order_by (481 samples, 1.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_comma_separated_with_trailing_commas (397 samples, 0.83%)libsystem_malloc.dylib`szone_malloc_should_clear (23 samples, 0.05%)libsystem_malloc.dylib`small_malloc_should_clear (18 samples, 0.04%)libsystem_malloc.dylib`small_malloc_from_free_list (15 samples, 0.03%)libsystem_malloc.dylib`small_free_list_remove_ptr_no_clear (5 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (173 samples, 0.36%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$memcpy (11 samples, 0.02%)libsystem_malloc.dylib`rack_get_thread_index (5 samples, 0.01%)libsystem_malloc.dylib`small_free_list_add_ptr (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ops::function::FnOnce::call_once (42 samples, 0.09%)libsystem_malloc.dylib`szone_malloc_should_clear (36 samples, 0.08%)libsystem_malloc.dylib`small_malloc_should_clear (26 samples, 0.05%)libsystem_malloc.dylib`small_malloc_from_free_list (21 samples, 0.04%)libsystem_malloc.dylib`small_free_list_remove_ptr_no_clear (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_comma_separated_with_trailing_commas (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_keyword (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_keywords (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_one_of_keywords (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_optional_group_by (5 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (106 samples, 0.22%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$memcpy (13 samples, 0.03%)libsystem_malloc.dylib`_malloc_zone_malloc (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (5 samples, 0.01%)libsystem_malloc.dylib`nanov2_malloc_type (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::expect_keyword (22 samples, 0.05%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::is_parse_comma_separated_end_with_trailing_commas (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_all_or_distinct (11 samples, 0.02%)libsystem_malloc.dylib`_free (7 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (6 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (195 samples, 0.41%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::cmp::PartialEq>::eq (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$memcpy (10 samples, 0.02%)libsystem_malloc.dylib`_malloc_zone_malloc (9 samples, 0.02%)libsystem_malloc.dylib`small_free_list_add_ptr (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVec<T,A>::grow_one (94 samples, 0.20%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (56 samples, 0.12%)libsystem_malloc.dylib`szone_malloc_should_clear (28 samples, 0.06%)libsystem_malloc.dylib`small_malloc_should_clear (19 samples, 0.04%)libsystem_malloc.dylib`small_malloc_from_free_list (13 samples, 0.03%)libsystem_malloc.dylib`small_free_list_remove_ptr_no_clear (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::is_parse_comma_separated_end_with_trailing_commas (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_optional_select_item_exclude (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_optional_select_item_ilike (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_optional_select_item_rename (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_wildcard_additional_options (48 samples, 0.10%)libsystem_platform.dylib`_platform_memmove (8 samples, 0.02%)libsystem_platform.dylib`_platform_memmove (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (7 samples, 0.01%)libsystem_malloc.dylib`nanov2_malloc_type (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (20 samples, 0.04%)libsystem_platform.dylib`_platform_memmove (24 samples, 0.05%)sqlparser_bench-959bc5267970ca34`sqlparser::dialect::Dialect::get_next_precedence_default (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::peek_token (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (11 samples, 0.02%)libsystem_malloc.dylib`_malloc_zone_malloc (6 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (22 samples, 0.05%)libsystem_platform.dylib`_platform_memmove (18 samples, 0.04%)libsystem_platform.dylib`_platform_memset (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (5 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (8 samples, 0.02%)libsystem_malloc.dylib`nanov2_pointer_size (8 samples, 0.02%)libsystem_malloc.dylib`nanov2_malloc (8 samples, 0.02%)libsystem_malloc.dylib`_malloc_zone_realloc (29 samples, 0.06%)libsystem_malloc.dylib`nanov2_realloc (16 samples, 0.03%)libsystem_malloc.dylib`_realloc (35 samples, 0.07%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVecInner<A>::reserve::do_reserve_and_handle (49 samples, 0.10%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (47 samples, 0.10%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (59 samples, 0.12%)libsystem_platform.dylib`_platform_memmove (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Location as core::fmt::Display>::fmt (94 samples, 0.20%)sqlparser_bench-959bc5267970ca34`core::fmt::write (93 samples, 0.20%)sqlparser_bench-959bc5267970ca34`core::fmt::num::imp::_<impl core::fmt::Display for u64>::fmt (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`alloc::fmt::format::format_inner (111 samples, 0.23%)sqlparser_bench-959bc5267970ca34`core::fmt::write (102 samples, 0.21%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::data_type::DataType> (26 samples, 0.05%)libsystem_malloc.dylib`_nanov2_free (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVec<T,A>::grow_one (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (5 samples, 0.01%)libsystem_malloc.dylib`nanov2_malloc_type (5 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (6 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (7 samples, 0.01%)libsystem_malloc.dylib`nanov2_malloc_type (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_object_name (48 samples, 0.10%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_identifier (30 samples, 0.06%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (10 samples, 0.02%)libsystem_malloc.dylib`_nanov2_free (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVecInner<A>::reserve::do_reserve_and_handle (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (6 samples, 0.01%)libsystem_malloc.dylib`nanov2_malloc_type (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (9 samples, 0.02%)libsystem_malloc.dylib`_malloc_zone_malloc (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVec<T,A>::grow_one (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_optional_type_modifiers (50 samples, 0.11%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_data_type_helper (111 samples, 0.23%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_data_type (118 samples, 0.25%)libsystem_platform.dylib`_platform_memmove (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_compound_field_access (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::tokenizer::Token> (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::expect_token (6 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::expect_token (23 samples, 0.05%)libsystem_malloc.dylib`_nanov2_free (5 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (16 samples, 0.03%)libsystem_malloc.dylib`_malloc_zone_malloc (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVec<T,A>::grow_one (32 samples, 0.07%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (21 samples, 0.04%)libsystem_malloc.dylib`szone_malloc_should_clear (18 samples, 0.04%)libsystem_malloc.dylib`small_malloc_should_clear (17 samples, 0.04%)libsystem_malloc.dylib`small_malloc_from_free_list (15 samples, 0.03%)libsystem_malloc.dylib`_nanov2_free (17 samples, 0.04%)libsystem_platform.dylib`_platform_memset (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (5 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVecInner<A>::reserve::do_reserve_and_handle (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (14 samples, 0.03%)libsystem_malloc.dylib`_nanov2_free (5 samples, 0.01%)libsystem_malloc.dylib`nanov2_realloc (11 samples, 0.02%)libsystem_malloc.dylib`_malloc_zone_realloc (15 samples, 0.03%)libsystem_malloc.dylib`_realloc (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (34 samples, 0.07%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVecInner<A>::reserve::do_reserve_and_handle (32 samples, 0.07%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (27 samples, 0.06%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Location as core::fmt::Display>::fmt (63 samples, 0.13%)sqlparser_bench-959bc5267970ca34`core::fmt::write (60 samples, 0.13%)sqlparser_bench-959bc5267970ca34`core::fmt::num::imp::_<impl core::fmt::Display for u64>::fmt (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`alloc::fmt::format::format_inner (106 samples, 0.22%)sqlparser_bench-959bc5267970ca34`core::fmt::write (97 samples, 0.20%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_function_named_arg_operator (117 samples, 0.25%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (8 samples, 0.02%)libsystem_platform.dylib`_platform_memmove (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_identifier (31 samples, 0.07%)libsystem_platform.dylib`_platform_memmove (8 samples, 0.02%)libsystem_platform.dylib`_platform_memmove (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (14 samples, 0.03%)libsystem_malloc.dylib`_free (5 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`sqlparser::dialect::Dialect::get_next_precedence_default (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::peek_token (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_keyword (8 samples, 0.02%)libsystem_malloc.dylib`_malloc_zone_malloc (5 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (7 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (7 samples, 0.01%)libsystem_malloc.dylib`nanov2_realloc (15 samples, 0.03%)libsystem_malloc.dylib`_malloc_zone_realloc (33 samples, 0.07%)libsystem_platform.dylib`_platform_memmove (10 samples, 0.02%)libsystem_malloc.dylib`_realloc (37 samples, 0.08%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVecInner<A>::reserve::do_reserve_and_handle (46 samples, 0.10%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (42 samples, 0.09%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (48 samples, 0.10%)libsystem_platform.dylib`_platform_memmove (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Location as core::fmt::Display>::fmt (79 samples, 0.17%)sqlparser_bench-959bc5267970ca34`core::fmt::write (78 samples, 0.16%)sqlparser_bench-959bc5267970ca34`core::fmt::num::imp::_<impl core::fmt::Display for u64>::fmt (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`alloc::fmt::format::format_inner (102 samples, 0.21%)sqlparser_bench-959bc5267970ca34`core::fmt::write (94 samples, 0.20%)libsystem_malloc.dylib`_nanov2_free (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::data_type::DataType> (19 samples, 0.04%)libsystem_malloc.dylib`_nanov2_free (6 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_object_name (46 samples, 0.10%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_identifier (38 samples, 0.08%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_data_type_helper (64 samples, 0.13%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_data_type (69 samples, 0.14%)libsystem_platform.dylib`_platform_memmove (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_expr_prefix_by_unreserved_word (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::try_parse (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_prefix (259 samples, 0.54%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_function_args (554 samples, 1.16%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_wildcard_expr (354 samples, 0.74%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_subexpr (318 samples, 0.67%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_comma_separated_with_trailing_commas (616 samples, 1.29%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_function_argument_list (706 samples, 1.48%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_json_null_clause (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_function_call (781 samples, 1.64%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_expr_prefix_by_unreserved_word (824 samples, 1.73%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_prefix (1,166 samples, 2.45%)sq..sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_select_item (1,371 samples, 2.88%)sq..sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_wildcard_expr (1,283 samples, 2.69%)sq..sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_subexpr (1,236 samples, 2.60%)sq..libsystem_malloc.dylib`_free (19 samples, 0.04%)libsystem_malloc.dylib`_nanov2_free (20 samples, 0.04%)libsystem_platform.dylib`_platform_memmove (50 samples, 0.11%)sqlparser_bench-959bc5267970ca34`<T as core::any::Any>::type_id (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (5 samples, 0.01%)libsystem_malloc.dylib`_malloc_zone_malloc (8 samples, 0.02%)libsystem_platform.dylib`_platform_memmove (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (12 samples, 0.03%)libsystem_malloc.dylib`nanov2_malloc_type (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (41 samples, 0.09%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$free (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$memcpy (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVec<T,A>::grow_one (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (15 samples, 0.03%)libsystem_malloc.dylib`szone_malloc_should_clear (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::tokenizer::Token> (22 samples, 0.05%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_join_constraint (31 samples, 0.07%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_parenthesized_column_list (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_identifier (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_keyword (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_keywords (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_object_name (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_one_of_keywords (9 samples, 0.02%)libsystem_malloc.dylib`_nanov2_free (37 samples, 0.08%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::cmp::PartialEq>::eq (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::tokenizer::Token> (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::consume_token (24 samples, 0.05%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::cmp::PartialEq>::eq (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::maybe_parse_table_sample (12 samples, 0.03%)libsystem_malloc.dylib`_free (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVec<T,A>::grow_one (32 samples, 0.07%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (27 samples, 0.06%)libsystem_malloc.dylib`nanov2_malloc_type (25 samples, 0.05%)libsystem_malloc.dylib`nanov2_allocate_outlined (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (6 samples, 0.01%)libsystem_malloc.dylib`_malloc_zone_malloc (5 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (19 samples, 0.04%)libsystem_malloc.dylib`nanov2_malloc_type (13 samples, 0.03%)libsystem_malloc.dylib`_malloc_zone_malloc (6 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (13 samples, 0.03%)libsystem_malloc.dylib`nanov2_malloc_type (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (34 samples, 0.07%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_object_name (170 samples, 0.36%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_identifier (98 samples, 0.21%)libsystem_malloc.dylib`_free (6 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (5 samples, 0.01%)libsystem_malloc.dylib`_malloc_zone_malloc (9 samples, 0.02%)libsystem_platform.dylib`_platform_memmove (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (14 samples, 0.03%)libsystem_malloc.dylib`nanov2_malloc_type (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_optional_table_alias (111 samples, 0.23%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_optional_alias (95 samples, 0.20%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (37 samples, 0.08%)libsystem_platform.dylib`_platform_memmove (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (12 samples, 0.03%)libsystem_malloc.dylib`nanov2_malloc_type (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::peek_token (40 samples, 0.08%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (33 samples, 0.07%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (5 samples, 0.01%)libsystem_malloc.dylib`_malloc_zone_malloc (12 samples, 0.03%)libsystem_platform.dylib`_platform_memmove (24 samples, 0.05%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (22 samples, 0.05%)libsystem_malloc.dylib`nanov2_malloc_type (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_table_factor (711 samples, 1.49%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::peek_tokens (208 samples, 0.44%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (91 samples, 0.19%)sqlparser_bench-959bc5267970ca34`__rdl_alloc (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_table_and_joins (1,055 samples, 2.22%)s..sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::peek_tokens (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_comma_separated_with_trailing_commas (2,821 samples, 5.92%)sqlparse..libsystem_malloc.dylib`_malloc_zone_malloc (15 samples, 0.03%)libsystem_platform.dylib`_platform_memmove (73 samples, 0.15%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$memcpy (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::tokenizer::Token> (6 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (7 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::dialect::Dialect::get_next_precedence_default (36 samples, 0.08%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::peek_token (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (10 samples, 0.02%)libsystem_malloc.dylib`rack_get_thread_index (10 samples, 0.02%)libsystem_malloc.dylib`tiny_malloc_from_free_list (8 samples, 0.02%)libsystem_malloc.dylib`set_tiny_meta_header_in_use (18 samples, 0.04%)libsystem_malloc.dylib`szone_malloc_should_clear (129 samples, 0.27%)libsystem_malloc.dylib`tiny_malloc_should_clear (95 samples, 0.20%)libsystem_malloc.dylib`tiny_malloc_from_free_list (59 samples, 0.12%)libsystem_malloc.dylib`tiny_free_list_add_ptr (8 samples, 0.02%)libsystem_malloc.dylib`tiny_malloc_should_clear (5 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$memcpy (6 samples, 0.01%)libsystem_malloc.dylib`_free (5 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (83 samples, 0.17%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$memcpy (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::tokenizer::Token> (6 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::dialect::Dialect::get_next_precedence_default (39 samples, 0.08%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::peek_token (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (10 samples, 0.02%)libsystem_malloc.dylib`set_tiny_meta_header_in_use (8 samples, 0.02%)libsystem_malloc.dylib`szone_malloc_should_clear (50 samples, 0.11%)libsystem_malloc.dylib`tiny_malloc_should_clear (42 samples, 0.09%)libsystem_malloc.dylib`tiny_malloc_from_free_list (30 samples, 0.06%)libsystem_platform.dylib`_platform_memmove (6 samples, 0.01%)libsystem_malloc.dylib`_free (6 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::dialect::Dialect::get_next_precedence_default (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::peek_token (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (10 samples, 0.02%)libsystem_malloc.dylib`_free (5 samples, 0.01%)libsystem_platform.dylib`_platform_memset (6 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVecInner<A>::reserve::do_reserve_and_handle (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (6 samples, 0.01%)libsystem_malloc.dylib`nanov2_malloc_type (6 samples, 0.01%)libsystem_malloc.dylib`nanov2_realloc (8 samples, 0.02%)libsystem_malloc.dylib`_malloc_zone_realloc (19 samples, 0.04%)libsystem_platform.dylib`_platform_memmove (5 samples, 0.01%)libsystem_malloc.dylib`_realloc (23 samples, 0.05%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVecInner<A>::reserve::do_reserve_and_handle (30 samples, 0.06%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (29 samples, 0.06%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (35 samples, 0.07%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::pad_integral (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Location as core::fmt::Display>::fmt (64 samples, 0.13%)sqlparser_bench-959bc5267970ca34`core::fmt::write (62 samples, 0.13%)sqlparser_bench-959bc5267970ca34`core::fmt::num::imp::_<impl core::fmt::Display for u64>::fmt (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::fmt::Display>::fmt (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`core::fmt::write (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`alloc::fmt::format::format_inner (142 samples, 0.30%)sqlparser_bench-959bc5267970ca34`core::fmt::write (130 samples, 0.27%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_data_type (168 samples, 0.35%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_data_type_helper (159 samples, 0.33%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_value (22 samples, 0.05%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_prefix (213 samples, 0.45%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_infix (349 samples, 0.73%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_subexpr (271 samples, 0.57%)libsystem_malloc.dylib`_free (6 samples, 0.01%)libsystem_malloc.dylib`_malloc_zone_malloc (9 samples, 0.02%)libsystem_malloc.dylib`_nanov2_free (20 samples, 0.04%)libsystem_platform.dylib`_platform_memset (11 samples, 0.02%)libsystem_malloc.dylib`nanov2_pointer_size (5 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (7 samples, 0.01%)libsystem_malloc.dylib`nanov2_malloc (5 samples, 0.01%)libsystem_malloc.dylib`nanov2_realloc (17 samples, 0.04%)libsystem_malloc.dylib`_malloc_zone_realloc (36 samples, 0.08%)libsystem_platform.dylib`_platform_memmove (6 samples, 0.01%)libsystem_malloc.dylib`_realloc (50 samples, 0.11%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVecInner<A>::reserve::do_reserve_and_handle (59 samples, 0.12%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (55 samples, 0.12%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (63 samples, 0.13%)libsystem_platform.dylib`_platform_memmove (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Location as core::fmt::Display>::fmt (91 samples, 0.19%)sqlparser_bench-959bc5267970ca34`core::fmt::write (89 samples, 0.19%)sqlparser_bench-959bc5267970ca34`core::fmt::num::imp::_<impl core::fmt::Display for u64>::fmt (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`alloc::fmt::format::format_inner (105 samples, 0.22%)sqlparser_bench-959bc5267970ca34`core::fmt::write (99 samples, 0.21%)libsystem_malloc.dylib`_nanov2_free (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::data_type::DataType> (13 samples, 0.03%)libsystem_malloc.dylib`_nanov2_free (6 samples, 0.01%)libsystem_malloc.dylib`_malloc_zone_malloc (6 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (5 samples, 0.01%)libsystem_platform.dylib`_platform_memset (7 samples, 0.01%)libsystem_malloc.dylib`nanov2_malloc_type (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::pad (6 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVecInner<A>::reserve::do_reserve_and_handle (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (6 samples, 0.01%)libsystem_malloc.dylib`nanov2_malloc_type (5 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (6 samples, 0.01%)libsystem_malloc.dylib`_realloc (5 samples, 0.01%)libsystem_malloc.dylib`nanov2_pointer_size (5 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (7 samples, 0.01%)libsystem_malloc.dylib`nanov2_malloc (8 samples, 0.02%)libsystem_malloc.dylib`nanov2_realloc (25 samples, 0.05%)libsystem_platform.dylib`_platform_memset (7 samples, 0.01%)libsystem_malloc.dylib`_malloc_zone_realloc (47 samples, 0.10%)libsystem_platform.dylib`_platform_memmove (9 samples, 0.02%)libsystem_malloc.dylib`_realloc (53 samples, 0.11%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (80 samples, 0.17%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVecInner<A>::reserve::do_reserve_and_handle (73 samples, 0.15%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (58 samples, 0.12%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::pad_integral (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Location as core::fmt::Display>::fmt (120 samples, 0.25%)sqlparser_bench-959bc5267970ca34`core::fmt::write (118 samples, 0.25%)sqlparser_bench-959bc5267970ca34`core::fmt::num::imp::_<impl core::fmt::Display for u64>::fmt (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<&T as core::fmt::Display>::fmt (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::fmt::Display>::fmt (29 samples, 0.06%)sqlparser_bench-959bc5267970ca34`core::fmt::write (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`alloc::fmt::format::format_inner (261 samples, 0.55%)sqlparser_bench-959bc5267970ca34`core::fmt::write (205 samples, 0.43%)sqlparser_bench-959bc5267970ca34`core::fmt::write (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVec<T,A>::grow_one (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (12 samples, 0.03%)libsystem_malloc.dylib`nanov2_malloc_type (6 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (6 samples, 0.01%)libsystem_malloc.dylib`nanov2_malloc_type (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_object_name (54 samples, 0.11%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_identifier (40 samples, 0.08%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_data_type (379 samples, 0.80%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_data_type_helper (360 samples, 0.76%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_data_type_helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_expr_prefix_by_unreserved_word (17 samples, 0.04%)libsystem_malloc.dylib`_nanov2_free (7 samples, 0.01%)libsystem_malloc.dylib`_malloc_zone_malloc (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_value (30 samples, 0.06%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (6 samples, 0.01%)libsystem_malloc.dylib`nanov2_malloc_type (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::try_parse (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_prefix (673 samples, 1.41%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_infix (1,392 samples, 2.92%)sq..sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_subexpr (1,215 samples, 2.55%)sq..sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_keyword (5 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (9 samples, 0.02%)libsystem_malloc.dylib`_malloc_zone_malloc (5 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (9 samples, 0.02%)libsystem_platform.dylib`_platform_memmove (26 samples, 0.05%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVecInner<A>::reserve::do_reserve_and_handle (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (9 samples, 0.02%)libsystem_malloc.dylib`nanov2_malloc_type (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (24 samples, 0.05%)libsystem_platform.dylib`_platform_memmove (6 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (5 samples, 0.01%)libsystem_malloc.dylib`nanov2_realloc (23 samples, 0.05%)libsystem_platform.dylib`_platform_memset (8 samples, 0.02%)libsystem_malloc.dylib`_malloc_zone_realloc (35 samples, 0.07%)libsystem_platform.dylib`_platform_memmove (5 samples, 0.01%)libsystem_malloc.dylib`_realloc (38 samples, 0.08%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVecInner<A>::reserve::do_reserve_and_handle (51 samples, 0.11%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (47 samples, 0.10%)libsystem_malloc.dylib`nanov2_size (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (61 samples, 0.13%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVecInner<A>::reserve::do_reserve_and_handle (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::pad_integral (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::pad_integral (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Location as core::fmt::Display>::fmt (128 samples, 0.27%)sqlparser_bench-959bc5267970ca34`core::fmt::write (123 samples, 0.26%)sqlparser_bench-959bc5267970ca34`core::fmt::num::imp::_<impl core::fmt::Display for u64>::fmt (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::pad_integral::write_prefix (5 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::fmt::Display>::fmt (26 samples, 0.05%)sqlparser_bench-959bc5267970ca34`core::fmt::write (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`alloc::fmt::format::format_inner (246 samples, 0.52%)sqlparser_bench-959bc5267970ca34`core::fmt::write (223 samples, 0.47%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_data_type (273 samples, 0.57%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_data_type_helper (269 samples, 0.56%)libsystem_malloc.dylib`_nanov2_free (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_value (28 samples, 0.06%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_prefix (343 samples, 0.72%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_subexpr (1,947 samples, 4.09%)sqlp..sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::peek_token (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_select (5,109 samples, 10.73%)sqlparser_bench-..sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_query_body (5,450 samples, 11.45%)sqlparser_bench-9..sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_select (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_query (8,118 samples, 17.05%)sqlparser_bench-959bc52679..sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_settings (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_statements (8,347 samples, 17.53%)sqlparser_bench-959bc526797..sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_statement (8,222 samples, 17.27%)sqlparser_bench-959bc526797..sqlparser_bench-959bc5267970ca34`sqlparser::tokenizer::Tokenizer::next_token (177 samples, 0.37%)sqlparser_bench-959bc5267970ca34`sqlparser::tokenizer::Tokenizer::tokenize_identifier_or_keyword (36 samples, 0.08%)libsystem_malloc.dylib`_free (161 samples, 0.34%)libsystem_malloc.dylib`_nanov2_free (39 samples, 0.08%)libsystem_platform.dylib`_platform_memmove (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::iter::traits::collect::FromIterator<char>>::from_iter (24 samples, 0.05%)sqlparser_bench-959bc5267970ca34`<sqlparser::dialect::generic::GenericDialect as sqlparser::dialect::Dialect>::is_delimited_identifier_start (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<sqlparser::dialect::mssql::MsSqlDialect as sqlparser::dialect::Dialect>::is_identifier_start (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$free (29 samples, 0.06%)sqlparser_bench-959bc5267970ca34`__rdl_dealloc (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$realloc (5 samples, 0.01%)libsystem_malloc.dylib`_malloc_zone_realloc (7 samples, 0.01%)libsystem_malloc.dylib`szone_good_size (6 samples, 0.01%)libsystem_malloc.dylib`_szone_free (5 samples, 0.01%)libsystem_malloc.dylib`tiny_free_list_add_ptr (6 samples, 0.01%)libsystem_malloc.dylib`free_tiny (29 samples, 0.06%)libsystem_malloc.dylib`tiny_free_no_lock (20 samples, 0.04%)libsystem_malloc.dylib`small_try_realloc_in_place (14 samples, 0.03%)libsystem_malloc.dylib`small_free_list_remove_ptr_no_clear (7 samples, 0.01%)libsystem_malloc.dylib`small_free_list_add_ptr (5 samples, 0.01%)libsystem_malloc.dylib`szone_malloc_should_clear (43 samples, 0.09%)libsystem_malloc.dylib`small_malloc_should_clear (33 samples, 0.07%)libsystem_malloc.dylib`small_malloc_from_free_list (28 samples, 0.06%)libsystem_malloc.dylib`small_free_list_remove_ptr_no_clear (7 samples, 0.01%)libsystem_malloc.dylib`szone_size (23 samples, 0.05%)libsystem_malloc.dylib`tiny_size (22 samples, 0.05%)libsystem_malloc.dylib`tiny_try_realloc_in_place (23 samples, 0.05%)libsystem_malloc.dylib`tiny_free_list_remove_ptr (6 samples, 0.01%)libsystem_malloc.dylib`szone_realloc (186 samples, 0.39%)libsystem_platform.dylib`_platform_memset (9 samples, 0.02%)libsystem_malloc.dylib`_malloc_zone_realloc (252 samples, 0.53%)libsystem_platform.dylib`_platform_memmove (29 samples, 0.06%)libsystem_malloc.dylib`_realloc (330 samples, 0.69%)libsystem_malloc.dylib`szone_size (42 samples, 0.09%)libsystem_malloc.dylib`tiny_size (40 samples, 0.08%)libsystem_malloc.dylib`szone_malloc_should_clear (47 samples, 0.10%)libsystem_malloc.dylib`tiny_malloc_should_clear (34 samples, 0.07%)libsystem_malloc.dylib`tiny_malloc_from_free_list (25 samples, 0.05%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVec<T,A>::grow_one (436 samples, 0.92%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (405 samples, 0.85%)sqlparser_bench-959bc5267970ca34`sqlparser::dialect::Dialect::is_custom_operator_part (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`sqlparser::tokenizer::State::next (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`sqlparser::tokenizer::State::peek (25 samples, 0.05%)sqlparser_bench-959bc5267970ca34`sqlparser::tokenizer::Tokenizer::consume_and_return (25 samples, 0.05%)libsystem_malloc.dylib`_free (9 samples, 0.02%)libsystem_malloc.dylib`_malloc_zone_malloc (13 samples, 0.03%)libsystem_malloc.dylib`_nanov2_free (30 samples, 0.06%)libsystem_platform.dylib`_platform_memcmp (80 samples, 0.17%)libsystem_platform.dylib`_platform_memmove (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<sqlparser::dialect::mssql::MsSqlDialect as sqlparser::dialect::Dialect>::is_identifier_part (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$memcmp (21 samples, 0.04%)libsystem_malloc.dylib`_malloc_zone_malloc (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVec<T,A>::grow_one (41 samples, 0.09%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (18 samples, 0.04%)libsystem_malloc.dylib`nanov2_malloc_type (17 samples, 0.04%)libsystem_malloc.dylib`nanov2_malloc_type (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::tokenizer::Token::make_word (33 samples, 0.07%)sqlparser_bench-959bc5267970ca34`alloc::str::_<impl str>::to_uppercase (12 samples, 0.03%)libsystem_malloc.dylib`nanov2_malloc_type (6 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (12 samples, 0.03%)libsystem_malloc.dylib`nanov2_malloc_type (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVec<T,A>::grow_one (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (5 samples, 0.01%)libsystem_malloc.dylib`nanov2_pointer_size (11 samples, 0.02%)libsystem_malloc.dylib`_realloc (30 samples, 0.06%)libsystem_malloc.dylib`_malloc_zone_realloc (23 samples, 0.05%)libsystem_malloc.dylib`nanov2_realloc (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVecInner<A>::reserve::do_reserve_and_handle (47 samples, 0.10%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (39 samples, 0.08%)libsystem_malloc.dylib`nanov2_size (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`sqlparser::tokenizer::Tokenizer::next_token (884 samples, 1.86%)s..sqlparser_bench-959bc5267970ca34`sqlparser::tokenizer::Tokenizer::tokenize_word (116 samples, 0.24%)libsystem_malloc.dylib`_free (37 samples, 0.08%)libsystem_malloc.dylib`_malloc_zone_malloc (39 samples, 0.08%)libsystem_malloc.dylib`_nanov2_free (231 samples, 0.49%)libsystem_platform.dylib`_platform_memcmp (593 samples, 1.25%)libsystem_platform.dylib`_platform_memmove (110 samples, 0.23%)libsystem_malloc.dylib`_malloc_zone_malloc (41 samples, 0.09%)sqlparser_bench-959bc5267970ca34`__rdl_alloc (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVecInner<A>::reserve::do_reserve_and_handle (183 samples, 0.38%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (83 samples, 0.17%)libsystem_malloc.dylib`nanov2_malloc_type (66 samples, 0.14%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::iter::traits::collect::FromIterator<char>>::from_iter (235 samples, 0.49%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<sqlparser::dialect::mssql::MsSqlDialect as sqlparser::dialect::Dialect>::is_identifier_part (119 samples, 0.25%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$free (28 samples, 0.06%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$malloc (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$memcmp (194 samples, 0.41%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$memcpy (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVec<T,A>::grow_one (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVecInner<A>::reserve::do_reserve_and_handle (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`alloc::str::_<impl str>::to_uppercase (38 samples, 0.08%)libsystem_malloc.dylib`_malloc_zone_malloc (42 samples, 0.09%)libsystem_malloc.dylib`nanov2_malloc_type (55 samples, 0.12%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$malloc (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`__rdl_alloc (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`sqlparser::tokenizer::Token::make_word (363 samples, 0.76%)sqlparser_bench-959bc5267970ca34`alloc::str::_<impl str>::to_uppercase (137 samples, 0.29%)libsystem_malloc.dylib`nanov2_malloc_type (59 samples, 0.12%)libsystem_malloc.dylib`_nanov2_free (78 samples, 0.16%)libsystem_malloc.dylib`_malloc_zone_malloc (46 samples, 0.10%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$malloc (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`__rdl_alloc (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVec<T,A>::grow_one (158 samples, 0.33%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (55 samples, 0.12%)libsystem_malloc.dylib`nanov2_malloc_type (43 samples, 0.09%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVecInner<A>::reserve::do_reserve_and_handle (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::tokenizer::Tokenizer::tokenize_identifier_or_keyword (2,644 samples, 5.55%)sqlpars..sqlparser_bench-959bc5267970ca34`sqlparser::tokenizer::Tokenizer::tokenize_word (528 samples, 1.11%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (22 samples, 0.05%)sqlparser_bench-959bc5267970ca34`sqlparser::tokenizer::Tokenizer::tokenize_with_location (5,051 samples, 10.61%)sqlparser_bench..sqlparser_bench-959bc5267970ca34`sqlparser::tokenizer::Tokenizer::tokenize_with_location_into_buf (4,835 samples, 10.15%)sqlparser_bench..sqlparser_bench-959bc5267970ca34`sqlparser::tokenizer::Tokenizer::tokenize_word (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::try_with_sql (5,081 samples, 10.67%)sqlparser_bench-..sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_sql (13,813 samples, 29.01%)sqlparser_bench-959bc5267970ca34`sqlparser::par..sqlparser_bench-959bc5267970ca34`criterion::bencher::Bencher<M>::iter (18,926 samples, 39.75%)sqlparser_bench-959bc5267970ca34`criterion::bencher::Bencher<M>::..sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::try_with_sql (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (18,946 samples, 39.79%)sqlparser_bench-959bc5267970ca34`<alloc::vec::Vec<T> as alloc::ve..libsystem_malloc.dylib`_free (8 samples, 0.02%)libsystem_malloc.dylib`_free (57 samples, 0.12%)libsystem_malloc.dylib`_nanov2_free (33 samples, 0.07%)libsystem_malloc.dylib`_szone_free (12 samples, 0.03%)libsystem_malloc.dylib`small_free_list_add_ptr (14 samples, 0.03%)libsystem_malloc.dylib`small_free_list_find_by_ptr (8 samples, 0.02%)libsystem_malloc.dylib`free_small (60 samples, 0.13%)libsystem_malloc.dylib`small_free_list_remove_ptr_no_clear (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<&T as core::fmt::Display>::fmt (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::query::OrderByExpr as core::fmt::Display>::fmt (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::pad (11 samples, 0.02%)libsystem_platform.dylib`_platform_memmove (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (22 samples, 0.05%)libsystem_platform.dylib`_platform_memmove (34 samples, 0.07%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$memcpy (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<&T as core::fmt::Display>::fmt (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Ident as core::fmt::Display>::fmt (5 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (43 samples, 0.09%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Ident as core::fmt::Display>::fmt (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (143 samples, 0.30%)sqlparser_bench-959bc5267970ca34`core::fmt::write (113 samples, 0.24%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::write_str (8 samples, 0.02%)libdyld.dylib`tlv_get_addr (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`psm::stack_pointer (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rust_psm_stack_pointer (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt (49 samples, 0.10%)sqlparser_bench-959bc5267970ca34`stacker::remaining_stack (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::write_fmt (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::fmt::write (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`recursive::get_minimum_stack_size (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`recursive::get_stack_allocation_size (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::query::OrderByExpr as core::fmt::Display>::fmt (376 samples, 0.79%)sqlparser_bench-959bc5267970ca34`core::fmt::write (282 samples, 0.59%)sqlparser_bench-959bc5267970ca34`stacker::remaining_stack (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<str as core::fmt::Display>::fmt (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::pad (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::DisplaySeparated<T> as core::fmt::Display>::fmt (542 samples, 1.14%)sqlparser_bench-959bc5267970ca34`core::fmt::write (500 samples, 1.05%)sqlparser_bench-959bc5267970ca34`core::fmt::write (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::query::OrderBy as core::fmt::Display>::fmt (570 samples, 1.20%)sqlparser_bench-959bc5267970ca34`core::fmt::write (570 samples, 1.20%)sqlparser_bench-959bc5267970ca34`core::fmt::write (28 samples, 0.06%)sqlparser_bench-959bc5267970ca34`<&T as core::fmt::Display>::fmt (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::pad (11 samples, 0.02%)libsystem_platform.dylib`_platform_memmove (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<&T as core::fmt::Display>::fmt (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::query::Join as core::fmt::Display>::fmt (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<<sqlparser::ast::query::Join as core::fmt::Display>::fmt::suffix::Suffix as core::fmt::Display>::fmt (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (30 samples, 0.06%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::query::TableFactor as core::fmt::Display>::fmt (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::pad (6 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (65 samples, 0.14%)sqlparser_bench-959bc5267970ca34`<<sqlparser::ast::query::Join as core::fmt::Display>::fmt::suffix::Suffix as core::fmt::Display>::fmt (20 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (42 samples, 0.09%)sqlparser_bench-959bc5267970ca34`<&T as core::fmt::Display>::fmt (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::DisplaySeparated<T> as core::fmt::Display>::fmt (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<&T as core::fmt::Display>::fmt (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Ident as core::fmt::Display>::fmt (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::pad (18 samples, 0.04%)libsystem_platform.dylib`_platform_memmove (38 samples, 0.08%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Ident as core::fmt::Display>::fmt (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<str as core::fmt::Display>::fmt (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::pad (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::DisplaySeparated<T> as core::fmt::Display>::fmt (232 samples, 0.49%)sqlparser_bench-959bc5267970ca34`core::fmt::write (161 samples, 0.34%)sqlparser_bench-959bc5267970ca34`<&T as core::fmt::Display>::fmt (311 samples, 0.65%)sqlparser_bench-959bc5267970ca34`core::fmt::write (272 samples, 0.57%)sqlparser_bench-959bc5267970ca34`core::fmt::write (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::query::TableFactor as core::fmt::Display>::fmt (412 samples, 0.87%)sqlparser_bench-959bc5267970ca34`core::fmt::write (347 samples, 0.73%)sqlparser_bench-959bc5267970ca34`core::fmt::write (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<str as core::fmt::Display>::fmt (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$memcpy (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::pad (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::query::Join as core::fmt::Display>::fmt (733 samples, 1.54%)sqlparser_bench-959bc5267970ca34`core::fmt::write (648 samples, 1.36%)sqlparser_bench-959bc5267970ca34`core::fmt::write (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<&T as core::fmt::Display>::fmt (801 samples, 1.68%)sqlparser_bench-959bc5267970ca34`core::fmt::write (780 samples, 1.64%)sqlparser_bench-959bc5267970ca34`core::fmt::write (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<&T as core::fmt::Display>::fmt (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (11 samples, 0.02%)libdyld.dylib`tlv_get_addr (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`psm::stack_pointer (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rust_psm_stack_pointer (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<&T as core::fmt::Display>::fmt (56 samples, 0.12%)sqlparser_bench-959bc5267970ca34`stacker::remaining_stack (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<&T as core::fmt::Display>::fmt (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Function as core::fmt::Display>::fmt (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::FunctionArguments as core::fmt::Display>::fmt (36 samples, 0.08%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (23 samples, 0.05%)libsystem_platform.dylib`_platform_memmove (24 samples, 0.05%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (27 samples, 0.06%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::DisplaySeparated<T> as core::fmt::Display>::fmt (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<&T as core::fmt::Display>::fmt (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::FunctionArg as core::fmt::Display>::fmt (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<str as core::fmt::Display>::fmt (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::pad (21 samples, 0.04%)libsystem_platform.dylib`_platform_memmove (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::FunctionArgExpr as core::fmt::Display>::fmt (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (11 samples, 0.02%)libdyld.dylib`tlv_get_addr (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`psm::stack_pointer (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rust_psm_stack_pointer (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<&T as core::fmt::Display>::fmt (40 samples, 0.08%)sqlparser_bench-959bc5267970ca34`stacker::remaining_stack (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<&T as core::fmt::Display>::fmt (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Ident as core::fmt::Display>::fmt (5 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (42 samples, 0.09%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Ident as core::fmt::Display>::fmt (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$memcpy (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (178 samples, 0.37%)sqlparser_bench-959bc5267970ca34`core::fmt::write (133 samples, 0.28%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::write_str (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::write_fmt (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::fmt::write (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`recursive::get_minimum_stack_size (23 samples, 0.05%)sqlparser_bench-959bc5267970ca34`recursive::get_stack_allocation_size (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::FunctionArgExpr as core::fmt::Display>::fmt (340 samples, 0.71%)sqlparser_bench-959bc5267970ca34`core::fmt::write (311 samples, 0.65%)sqlparser_bench-959bc5267970ca34`stacker::remaining_stack (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::FunctionArg as core::fmt::Display>::fmt (401 samples, 0.84%)sqlparser_bench-959bc5267970ca34`core::fmt::write (378 samples, 0.79%)sqlparser_bench-959bc5267970ca34`core::fmt::write (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::pad (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::DisplaySeparated<T> as core::fmt::Display>::fmt (580 samples, 1.22%)sqlparser_bench-959bc5267970ca34`core::fmt::write (508 samples, 1.07%)sqlparser_bench-959bc5267970ca34`core::fmt::write (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::FunctionArgumentList as core::fmt::Display>::fmt (655 samples, 1.38%)sqlparser_bench-959bc5267970ca34`core::fmt::write (637 samples, 1.34%)sqlparser_bench-959bc5267970ca34`core::fmt::write (25 samples, 0.05%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$memcpy (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::FunctionArguments as core::fmt::Display>::fmt (813 samples, 1.71%)sqlparser_bench-959bc5267970ca34`core::fmt::write (772 samples, 1.62%)sqlparser_bench-959bc5267970ca34`core::fmt::write (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::DisplaySeparated<T> as core::fmt::Display>::fmt (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<&T as core::fmt::Display>::fmt (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (29 samples, 0.06%)sqlparser_bench-959bc5267970ca34`<str as core::fmt::Display>::fmt (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::pad (15 samples, 0.03%)libsystem_platform.dylib`_platform_memmove (49 samples, 0.10%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (23 samples, 0.05%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Ident as core::fmt::Display>::fmt (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::pad (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::DisplaySeparated<T> as core::fmt::Display>::fmt (239 samples, 0.50%)sqlparser_bench-959bc5267970ca34`core::fmt::write (152 samples, 0.32%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::ObjectName as core::fmt::Display>::fmt (320 samples, 0.67%)sqlparser_bench-959bc5267970ca34`core::fmt::write (294 samples, 0.62%)sqlparser_bench-959bc5267970ca34`core::fmt::write (22 samples, 0.05%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Function as core::fmt::Display>::fmt (1,284 samples, 2.70%)sq..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,221 samples, 2.56%)sq..sqlparser_bench-959bc5267970ca34`core::fmt::write (27 samples, 0.06%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,364 samples, 2.86%)sq..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,331 samples, 2.80%)sq..sqlparser_bench-959bc5267970ca34`core::fmt::write (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`core::fmt::write (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`recursive::get_minimum_stack_size (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`recursive::get_stack_allocation_size (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::query::SelectItem as core::fmt::Display>::fmt (1,540 samples, 3.23%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,504 samples, 3.16%)sql..sqlparser_bench-959bc5267970ca34`stacker::remaining_stack (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::pad (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::DisplaySeparated<T> as core::fmt::Display>::fmt (2,493 samples, 5.24%)sqlpar..sqlparser_bench-959bc5267970ca34`core::fmt::write (2,446 samples, 5.14%)sqlpar..sqlparser_bench-959bc5267970ca34`core::fmt::write (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::fmt::write (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::fmt::write (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`core::fmt::write (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`core::fmt::write (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`core::fmt::write (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`core::fmt::write (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (23 samples, 0.05%)sqlparser_bench-959bc5267970ca34`core::fmt::write (22 samples, 0.05%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`core::fmt::write (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (26 samples, 0.05%)sqlparser_bench-959bc5267970ca34`core::fmt::write (26 samples, 0.05%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (26 samples, 0.05%)sqlparser_bench-959bc5267970ca34`core::fmt::write (25 samples, 0.05%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (27 samples, 0.06%)sqlparser_bench-959bc5267970ca34`core::fmt::write (27 samples, 0.06%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (27 samples, 0.06%)sqlparser_bench-959bc5267970ca34`core::fmt::write (27 samples, 0.06%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (27 samples, 0.06%)sqlparser_bench-959bc5267970ca34`core::fmt::write (27 samples, 0.06%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (30 samples, 0.06%)sqlparser_bench-959bc5267970ca34`core::fmt::write (30 samples, 0.06%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (30 samples, 0.06%)sqlparser_bench-959bc5267970ca34`core::fmt::write (29 samples, 0.06%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (29 samples, 0.06%)sqlparser_bench-959bc5267970ca34`core::fmt::write (29 samples, 0.06%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (32 samples, 0.07%)sqlparser_bench-959bc5267970ca34`core::fmt::write (32 samples, 0.07%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (31 samples, 0.07%)sqlparser_bench-959bc5267970ca34`core::fmt::write (31 samples, 0.07%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (33 samples, 0.07%)sqlparser_bench-959bc5267970ca34`core::fmt::write (33 samples, 0.07%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (36 samples, 0.08%)sqlparser_bench-959bc5267970ca34`core::fmt::write (36 samples, 0.08%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (35 samples, 0.07%)sqlparser_bench-959bc5267970ca34`core::fmt::write (35 samples, 0.07%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (34 samples, 0.07%)sqlparser_bench-959bc5267970ca34`core::fmt::write (34 samples, 0.07%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (38 samples, 0.08%)sqlparser_bench-959bc5267970ca34`core::fmt::write (38 samples, 0.08%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (38 samples, 0.08%)sqlparser_bench-959bc5267970ca34`core::fmt::write (38 samples, 0.08%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (41 samples, 0.09%)sqlparser_bench-959bc5267970ca34`core::fmt::write (40 samples, 0.08%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (40 samples, 0.08%)sqlparser_bench-959bc5267970ca34`core::fmt::write (40 samples, 0.08%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (39 samples, 0.08%)sqlparser_bench-959bc5267970ca34`core::fmt::write (39 samples, 0.08%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (44 samples, 0.09%)sqlparser_bench-959bc5267970ca34`core::fmt::write (42 samples, 0.09%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (48 samples, 0.10%)sqlparser_bench-959bc5267970ca34`core::fmt::write (47 samples, 0.10%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (47 samples, 0.10%)sqlparser_bench-959bc5267970ca34`core::fmt::write (47 samples, 0.10%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (46 samples, 0.10%)sqlparser_bench-959bc5267970ca34`core::fmt::write (45 samples, 0.09%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (51 samples, 0.11%)sqlparser_bench-959bc5267970ca34`core::fmt::write (51 samples, 0.11%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (51 samples, 0.11%)sqlparser_bench-959bc5267970ca34`core::fmt::write (51 samples, 0.11%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (51 samples, 0.11%)sqlparser_bench-959bc5267970ca34`core::fmt::write (51 samples, 0.11%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (51 samples, 0.11%)sqlparser_bench-959bc5267970ca34`core::fmt::write (51 samples, 0.11%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (50 samples, 0.11%)sqlparser_bench-959bc5267970ca34`core::fmt::write (50 samples, 0.11%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Statement as core::fmt::Display>::fmt (3,140 samples, 6.59%)sqlparser..sqlparser_bench-959bc5267970ca34`core::fmt::write (3,140 samples, 6.59%)sqlparser..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::query::Query as core::fmt::Display>::fmt (3,140 samples, 6.59%)sqlparser..sqlparser_bench-959bc5267970ca34`core::fmt::write (3,140 samples, 6.59%)sqlparser..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::query::SetExpr as core::fmt::Display>::fmt (2,570 samples, 5.40%)sqlpars..sqlparser_bench-959bc5267970ca34`core::fmt::write (2,570 samples, 5.40%)sqlpars..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::query::Select as core::fmt::Display>::fmt (2,570 samples, 5.40%)sqlpars..sqlparser_bench-959bc5267970ca34`core::fmt::write (2,570 samples, 5.40%)sqlpars..sqlparser_bench-959bc5267970ca34`core::fmt::write (26 samples, 0.05%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$free (24 samples, 0.05%)libsystem_malloc.dylib`_free (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$free (5 samples, 0.01%)libsystem_malloc.dylib`_free (14 samples, 0.03%)libsystem_malloc.dylib`_nanov2_free (12 samples, 0.03%)libsystem_malloc.dylib`_szone_free (18 samples, 0.04%)libsystem_malloc.dylib`small_free_list_add_ptr (8 samples, 0.02%)libsystem_malloc.dylib`small_free_list_remove_ptr (7 samples, 0.01%)libsystem_malloc.dylib`free_small (64 samples, 0.13%)libsystem_malloc.dylib`small_free_list_remove_ptr_no_clear (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$free (8 samples, 0.02%)libsystem_malloc.dylib`_free (7 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (7 samples, 0.01%)libsystem_malloc.dylib`free_small (7 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (8 samples, 0.02%)libsystem_malloc.dylib`free_small (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Function> (28 samples, 0.06%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::FunctionArgumentList> (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::query::Cte> (77 samples, 0.16%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::query::Query> (69 samples, 0.14%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::query::SetExpr> (53 samples, 0.11%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::query::SelectItem> (32 samples, 0.07%)libsystem_malloc.dylib`_nanov2_free (12 samples, 0.03%)libsystem_malloc.dylib`free_medium (28 samples, 0.06%)libsystem_kernel.dylib`madvise (28 samples, 0.06%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::query::OrderBy> (42 samples, 0.09%)libsystem_malloc.dylib`_free (10 samples, 0.02%)libsystem_malloc.dylib`_nanov2_free (20 samples, 0.04%)libsystem_malloc.dylib`_szone_free (10 samples, 0.02%)libsystem_malloc.dylib`free_medium (27 samples, 0.06%)libsystem_kernel.dylib`madvise (27 samples, 0.06%)libsystem_malloc.dylib`small_free_list_add_ptr (14 samples, 0.03%)libsystem_malloc.dylib`small_free_list_find_by_ptr (5 samples, 0.01%)libsystem_malloc.dylib`free_small (64 samples, 0.13%)libsystem_malloc.dylib`small_free_list_remove_ptr_no_clear (8 samples, 0.02%)libsystem_malloc.dylib`tiny_free_list_add_ptr (5 samples, 0.01%)libsystem_malloc.dylib`free_tiny (40 samples, 0.08%)libsystem_malloc.dylib`tiny_free_no_lock (23 samples, 0.05%)libsystem_malloc.dylib`tiny_free_list_remove_ptr (6 samples, 0.01%)libsystem_malloc.dylib`_free (6 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (11 samples, 0.02%)libsystem_malloc.dylib`free_medium (12 samples, 0.03%)libsystem_kernel.dylib`madvise (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$free (5 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (45 samples, 0.09%)libsystem_malloc.dylib`nanov2_madvise_block (13 samples, 0.03%)libsystem_malloc.dylib`nanov2_madvise_block_locked (13 samples, 0.03%)libsystem_kernel.dylib`madvise (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<alloc::vec::Vec<T,A> as core::ops::drop::Drop>::drop (133 samples, 0.28%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::query::TableFactor> (89 samples, 0.19%)libsystem_platform.dylib`_platform_memset (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$free (9 samples, 0.02%)libsystem_malloc.dylib`_nanov2_free (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (11 samples, 0.02%)libsystem_malloc.dylib`_free (6 samples, 0.01%)libsystem_malloc.dylib`free_tiny (25 samples, 0.05%)libsystem_malloc.dylib`tiny_free_no_lock (15 samples, 0.03%)libsystem_malloc.dylib`tiny_free_list_add_ptr (9 samples, 0.02%)libsystem_malloc.dylib`_nanov2_free (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (56 samples, 0.12%)libsystem_malloc.dylib`_nanov2_free (11 samples, 0.02%)libsystem_malloc.dylib`_nanov2_free (5 samples, 0.01%)libsystem_malloc.dylib`_szone_free (7 samples, 0.01%)libsystem_malloc.dylib`small_free_list_add_ptr (14 samples, 0.03%)libsystem_malloc.dylib`free_small (28 samples, 0.06%)libsystem_malloc.dylib`small_free_list_remove_ptr_no_clear (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Function> (63 samples, 0.13%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::FunctionArgumentList> (44 samples, 0.09%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::query::SetExpr> (478 samples, 1.00%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::query::Query>> (753 samples, 1.58%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::query::Query> (737 samples, 1.55%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::tokenizer::Token> (142 samples, 0.30%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::tokenizer::Whitespace> (32 samples, 0.07%)libsystem_malloc.dylib`_nanov2_free (121 samples, 0.25%)libsystem_malloc.dylib`free_medium (45 samples, 0.09%)libsystem_kernel.dylib`madvise (45 samples, 0.09%)libsystem_malloc.dylib`free_small (5 samples, 0.01%)libsystem_malloc.dylib`nanov2_madvise_block (6 samples, 0.01%)libsystem_malloc.dylib`nanov2_madvise_block_locked (6 samples, 0.01%)libsystem_kernel.dylib`madvise (6 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (95 samples, 0.20%)libsystem_platform.dylib`_platform_memset (6 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (10 samples, 0.02%)libsystem_malloc.dylib`_malloc_zone_malloc (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (9 samples, 0.02%)libsystem_malloc.dylib`nanov2_malloc_type (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (27 samples, 0.06%)libsystem_malloc.dylib`small_free_list_add_ptr (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVec<T,A>::grow_one (80 samples, 0.17%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (58 samples, 0.12%)libsystem_malloc.dylib`szone_malloc_should_clear (36 samples, 0.08%)libsystem_malloc.dylib`small_malloc_should_clear (30 samples, 0.06%)libsystem_malloc.dylib`small_malloc_from_free_list (25 samples, 0.05%)libsystem_malloc.dylib`small_free_list_remove_ptr_no_clear (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::tokenizer::Token> (6 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (14 samples, 0.03%)libsystem_platform.dylib`_platform_memmove (54 samples, 0.11%)libsystem_malloc.dylib`_malloc_zone_malloc (6 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (30 samples, 0.06%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_keyword (8 samples, 0.02%)libsystem_malloc.dylib`_malloc_zone_malloc (5 samples, 0.01%)libsystem_malloc.dylib`szone_malloc_should_clear (5 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (138 samples, 0.29%)libsystem_malloc.dylib`small_free_list_add_ptr (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`alloc::alloc::exchange_malloc (35 samples, 0.07%)libsystem_malloc.dylib`szone_malloc_should_clear (32 samples, 0.07%)libsystem_malloc.dylib`small_malloc_should_clear (24 samples, 0.05%)libsystem_malloc.dylib`small_malloc_from_free_list (23 samples, 0.05%)libsystem_malloc.dylib`small_free_list_remove_ptr_no_clear (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVec<T,A>::grow_one (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::tokenizer::Token> (11 samples, 0.02%)libsystem_platform.dylib`_platform_memmove (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::expect_token (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_identifier (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_keyword (8 samples, 0.02%)libsystem_platform.dylib`_platform_memmove (19 samples, 0.04%)libsystem_platform.dylib`_platform_memmove (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`core::ops::function::FnOnce::call_once (6 samples, 0.01%)libsystem_malloc.dylib`szone_malloc_should_clear (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_keyword (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_keywords (5 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::expect_keyword (6 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVec<T,A>::grow_one (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (13 samples, 0.03%)libsystem_malloc.dylib`szone_malloc_should_clear (5 samples, 0.01%)libsystem_malloc.dylib`small_malloc_should_clear (5 samples, 0.01%)libsystem_malloc.dylib`small_malloc_from_free_list (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_optional_alias (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (10 samples, 0.02%)libsystem_malloc.dylib`_nanov2_free (6 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (6 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$free (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::dialect::Dialect::get_next_precedence_default (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::peek_token (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_keyword (7 samples, 0.01%)libsystem_malloc.dylib`_free (5 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (9 samples, 0.02%)libsystem_platform.dylib`_platform_memmove (8 samples, 0.02%)libsystem_platform.dylib`_platform_memset (5 samples, 0.01%)libsystem_malloc.dylib`nanov2_malloc (7 samples, 0.01%)libsystem_malloc.dylib`nanov2_realloc (13 samples, 0.03%)libsystem_malloc.dylib`_malloc_zone_realloc (20 samples, 0.04%)libsystem_malloc.dylib`_realloc (23 samples, 0.05%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (34 samples, 0.07%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVecInner<A>::reserve::do_reserve_and_handle (33 samples, 0.07%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (28 samples, 0.06%)sqlparser_bench-959bc5267970ca34`alloc::fmt::format::format_inner (67 samples, 0.14%)sqlparser_bench-959bc5267970ca34`core::fmt::write (66 samples, 0.14%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Location as core::fmt::Display>::fmt (61 samples, 0.13%)sqlparser_bench-959bc5267970ca34`core::fmt::write (58 samples, 0.12%)sqlparser_bench-959bc5267970ca34`core::fmt::num::imp::_<impl core::fmt::Display for u64>::fmt (14 samples, 0.03%)libsystem_malloc.dylib`_nanov2_free (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::data_type::DataType> (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVec<T,A>::grow_one (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (9 samples, 0.02%)libsystem_malloc.dylib`nanov2_malloc_type (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_object_name (46 samples, 0.10%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_identifier (23 samples, 0.05%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_data_type_helper (96 samples, 0.20%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_optional_type_modifiers (27 samples, 0.06%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_data_type (99 samples, 0.21%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_compound_field_access (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (5 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVec<T,A>::grow_one (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (7 samples, 0.01%)libsystem_malloc.dylib`szone_malloc_should_clear (5 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (7 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (10 samples, 0.02%)libsystem_malloc.dylib`nanov2_realloc (7 samples, 0.01%)libsystem_malloc.dylib`_realloc (13 samples, 0.03%)libsystem_malloc.dylib`_malloc_zone_realloc (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVecInner<A>::reserve::do_reserve_and_handle (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Location as core::fmt::Display>::fmt (35 samples, 0.07%)sqlparser_bench-959bc5267970ca34`core::fmt::write (34 samples, 0.07%)sqlparser_bench-959bc5267970ca34`core::fmt::num::imp::_<impl core::fmt::Display for u64>::fmt (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`alloc::fmt::format::format_inner (62 samples, 0.13%)sqlparser_bench-959bc5267970ca34`core::fmt::write (52 samples, 0.11%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_function_named_arg_operator (70 samples, 0.15%)libsystem_malloc.dylib`_nanov2_free (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_identifier (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (8 samples, 0.02%)libsystem_platform.dylib`_platform_memmove (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVecInner<A>::reserve::do_reserve_and_handle (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (13 samples, 0.03%)libsystem_malloc.dylib`_realloc (13 samples, 0.03%)libsystem_malloc.dylib`_malloc_zone_realloc (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`alloc::fmt::format::format_inner (33 samples, 0.07%)sqlparser_bench-959bc5267970ca34`core::fmt::write (26 samples, 0.05%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Location as core::fmt::Display>::fmt (25 samples, 0.05%)sqlparser_bench-959bc5267970ca34`core::fmt::write (24 samples, 0.05%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::data_type::DataType> (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_object_name (22 samples, 0.05%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_identifier (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_data_type_helper (26 samples, 0.05%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_data_type (29 samples, 0.06%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_prefix (93 samples, 0.20%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_function_args (239 samples, 0.50%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_wildcard_expr (136 samples, 0.29%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_subexpr (120 samples, 0.25%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_function_argument_list (315 samples, 0.66%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_comma_separated_with_trailing_commas (274 samples, 0.58%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_function_call (334 samples, 0.70%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_expr_prefix_by_unreserved_word (364 samples, 0.76%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_prefix (614 samples, 1.29%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::try_parse (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_select_item (740 samples, 1.55%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_wildcard_expr (698 samples, 1.47%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_subexpr (669 samples, 1.40%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_object_name (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_identifier (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::peek_token (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_table_factor (58 samples, 0.12%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::peek_tokens (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_comma_separated_with_trailing_commas (865 samples, 1.82%)s..sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_table_and_joins (82 samples, 0.17%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVec<T,A>::grow_one (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (5 samples, 0.01%)libsystem_malloc.dylib`nanov2_realloc (6 samples, 0.01%)libsystem_malloc.dylib`_malloc_zone_realloc (13 samples, 0.03%)libsystem_malloc.dylib`_realloc (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVecInner<A>::reserve::do_reserve_and_handle (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`alloc::fmt::format::format_inner (29 samples, 0.06%)sqlparser_bench-959bc5267970ca34`core::fmt::write (27 samples, 0.06%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Location as core::fmt::Display>::fmt (27 samples, 0.06%)sqlparser_bench-959bc5267970ca34`core::fmt::write (26 samples, 0.05%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::data_type::DataType> (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_object_name (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_identifier (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_data_type_helper (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_data_type (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_optional_group_by (93 samples, 0.20%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_subexpr (76 samples, 0.16%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_prefix (68 samples, 0.14%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_query (1,096 samples, 2.30%)s..sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_query_body (1,055 samples, 2.22%)s..sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_select (1,000 samples, 2.10%)s..sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_cte (1,138 samples, 2.39%)sq..libsystem_platform.dylib`_platform_memmove (79 samples, 0.17%)libsystem_platform.dylib`_platform_memmove (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVec<T,A>::grow_one (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (11 samples, 0.02%)libsystem_malloc.dylib`_realloc (11 samples, 0.02%)libsystem_malloc.dylib`_malloc_zone_realloc (11 samples, 0.02%)libsystem_platform.dylib`_platform_memmove (7 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (13 samples, 0.03%)libsystem_platform.dylib`_platform_memmove (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`sqlparser::dialect::Dialect::get_next_precedence_default (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::peek_token (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (8 samples, 0.02%)libsystem_malloc.dylib`_nanov2_free (10 samples, 0.02%)libsystem_platform.dylib`_platform_memmove (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (6 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (6 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (5 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (12 samples, 0.03%)libsystem_malloc.dylib`nanov2_malloc (5 samples, 0.01%)libsystem_malloc.dylib`nanov2_realloc (20 samples, 0.04%)libsystem_malloc.dylib`_realloc (42 samples, 0.09%)libsystem_malloc.dylib`_malloc_zone_realloc (39 samples, 0.08%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVecInner<A>::reserve::do_reserve_and_handle (51 samples, 0.11%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (45 samples, 0.09%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (54 samples, 0.11%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Location as core::fmt::Display>::fmt (84 samples, 0.18%)sqlparser_bench-959bc5267970ca34`core::fmt::write (81 samples, 0.17%)sqlparser_bench-959bc5267970ca34`core::fmt::num::imp::_<impl core::fmt::Display for u64>::fmt (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`alloc::fmt::format::format_inner (99 samples, 0.21%)sqlparser_bench-959bc5267970ca34`core::fmt::write (93 samples, 0.20%)libsystem_malloc.dylib`_nanov2_free (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::data_type::DataType> (16 samples, 0.03%)libsystem_platform.dylib`_platform_memmove (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_object_name (50 samples, 0.11%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_identifier (37 samples, 0.08%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_data_type_helper (61 samples, 0.13%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_data_type (65 samples, 0.14%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_expr_prefix_by_unreserved_word (30 samples, 0.06%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_prefix (269 samples, 0.56%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_comma_separated_with_trailing_commas (377 samples, 0.79%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_order_by_expr (348 samples, 0.73%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_subexpr (323 samples, 0.68%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_optional_order_by (462 samples, 0.97%)libsystem_malloc.dylib`small_free_list_add_ptr (6 samples, 0.01%)libsystem_malloc.dylib`szone_malloc_should_clear (36 samples, 0.08%)libsystem_malloc.dylib`small_malloc_should_clear (23 samples, 0.05%)libsystem_malloc.dylib`small_malloc_from_free_list (20 samples, 0.04%)libsystem_platform.dylib`_platform_memmove (139 samples, 0.29%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$memcpy (9 samples, 0.02%)libsystem_malloc.dylib`small_free_list_remove_ptr (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ops::function::FnOnce::call_once (40 samples, 0.08%)libsystem_malloc.dylib`szone_malloc_should_clear (34 samples, 0.07%)libsystem_malloc.dylib`small_malloc_should_clear (25 samples, 0.05%)libsystem_malloc.dylib`small_malloc_from_free_list (22 samples, 0.05%)libsystem_malloc.dylib`small_free_list_remove_ptr_no_clear (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_comma_separated_with_trailing_commas (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_keyword (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_keywords (13 samples, 0.03%)libsystem_platform.dylib`_platform_memmove (95 samples, 0.20%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$memcpy (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::tokenizer::Token> (6 samples, 0.01%)libsystem_malloc.dylib`_malloc_zone_malloc (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (9 samples, 0.02%)libsystem_malloc.dylib`nanov2_malloc_type (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::expect_keyword (38 samples, 0.08%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (22 samples, 0.05%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::is_parse_comma_separated_end_with_trailing_commas (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_all_or_distinct (12 samples, 0.03%)libsystem_malloc.dylib`_free (7 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (191 samples, 0.40%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$memcpy (8 samples, 0.02%)libsystem_malloc.dylib`_malloc_zone_malloc (16 samples, 0.03%)libsystem_malloc.dylib`_realloc (7 samples, 0.01%)libsystem_malloc.dylib`_malloc_zone_realloc (7 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (6 samples, 0.01%)libsystem_malloc.dylib`rack_get_thread_index (5 samples, 0.01%)libsystem_malloc.dylib`small_free_list_add_ptr (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVec<T,A>::grow_one (104 samples, 0.22%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (72 samples, 0.15%)libsystem_malloc.dylib`szone_malloc_should_clear (47 samples, 0.10%)libsystem_malloc.dylib`small_malloc_should_clear (32 samples, 0.07%)libsystem_malloc.dylib`small_malloc_from_free_list (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::is_parse_comma_separated_end_with_trailing_commas (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::cmp::PartialEq>::eq (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_optional_select_item_exclude (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_optional_select_item_rename (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_wildcard_additional_options (56 samples, 0.12%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_optional_select_item_replace (5 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (7 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (6 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::cmp::PartialEq>::eq (6 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (23 samples, 0.05%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$memcpy (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::dialect::Dialect::get_next_precedence_default (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::peek_token (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (12 samples, 0.03%)libsystem_malloc.dylib`_malloc_zone_malloc (5 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (13 samples, 0.03%)libsystem_platform.dylib`_platform_memmove (17 samples, 0.04%)libsystem_platform.dylib`_platform_memset (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (8 samples, 0.02%)libsystem_malloc.dylib`nanov2_malloc_type (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$free (5 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (9 samples, 0.02%)libsystem_malloc.dylib`nanov2_realloc (18 samples, 0.04%)libsystem_malloc.dylib`_malloc_zone_realloc (30 samples, 0.06%)libsystem_platform.dylib`_platform_memmove (8 samples, 0.02%)libsystem_malloc.dylib`_realloc (41 samples, 0.09%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVecInner<A>::reserve::do_reserve_and_handle (51 samples, 0.11%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (45 samples, 0.09%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (56 samples, 0.12%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Location as core::fmt::Display>::fmt (79 samples, 0.17%)sqlparser_bench-959bc5267970ca34`core::fmt::write (78 samples, 0.16%)sqlparser_bench-959bc5267970ca34`core::fmt::num::imp::_<impl core::fmt::Display for u64>::fmt (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`alloc::fmt::format::format_inner (88 samples, 0.18%)sqlparser_bench-959bc5267970ca34`core::fmt::write (84 samples, 0.18%)libsystem_malloc.dylib`_nanov2_free (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::data_type::DataType> (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVec<T,A>::grow_one (9 samples, 0.02%)libsystem_platform.dylib`_platform_memmove (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (8 samples, 0.02%)libsystem_malloc.dylib`nanov2_malloc_type (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_object_name (62 samples, 0.13%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_identifier (38 samples, 0.08%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVecInner<A>::reserve::do_reserve_and_handle (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (6 samples, 0.01%)libsystem_malloc.dylib`nanov2_malloc_type (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (13 samples, 0.03%)libsystem_platform.dylib`_platform_memmove (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVec<T,A>::grow_one (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_optional_type_modifiers (53 samples, 0.11%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_data_type_helper (130 samples, 0.27%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_data_type (131 samples, 0.28%)libsystem_platform.dylib`_platform_memmove (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_compound_field_access (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::tokenizer::Token> (5 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (5 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (25 samples, 0.05%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (8 samples, 0.02%)libsystem_malloc.dylib`nanov2_malloc_type (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::expect_token (19 samples, 0.04%)libsystem_malloc.dylib`_nanov2_free (12 samples, 0.03%)libsystem_platform.dylib`_platform_memmove (14 samples, 0.03%)libsystem_malloc.dylib`small_free_list_add_ptr (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVec<T,A>::grow_one (34 samples, 0.07%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (26 samples, 0.05%)libsystem_malloc.dylib`szone_malloc_should_clear (22 samples, 0.05%)libsystem_malloc.dylib`small_malloc_should_clear (22 samples, 0.05%)libsystem_malloc.dylib`small_malloc_from_free_list (18 samples, 0.04%)libsystem_malloc.dylib`small_free_list_remove_ptr_no_clear (5 samples, 0.01%)libsystem_malloc.dylib`_free (8 samples, 0.02%)libsystem_malloc.dylib`_nanov2_free (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$free (5 samples, 0.01%)libsystem_malloc.dylib`nanov2_malloc_type (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (5 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVecInner<A>::reserve::do_reserve_and_handle (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (9 samples, 0.02%)libsystem_malloc.dylib`nanov2_realloc (10 samples, 0.02%)libsystem_malloc.dylib`_realloc (20 samples, 0.04%)libsystem_malloc.dylib`_malloc_zone_realloc (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVecInner<A>::reserve::do_reserve_and_handle (24 samples, 0.05%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (23 samples, 0.05%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (28 samples, 0.06%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Location as core::fmt::Display>::fmt (52 samples, 0.11%)sqlparser_bench-959bc5267970ca34`core::fmt::write (51 samples, 0.11%)sqlparser_bench-959bc5267970ca34`core::fmt::num::imp::_<impl core::fmt::Display for u64>::fmt (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::fmt::Display>::fmt (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`alloc::fmt::format::format_inner (115 samples, 0.24%)sqlparser_bench-959bc5267970ca34`core::fmt::write (96 samples, 0.20%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_function_named_arg_operator (131 samples, 0.28%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (9 samples, 0.02%)libsystem_malloc.dylib`nanov2_malloc_type (5 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (7 samples, 0.01%)libsystem_malloc.dylib`nanov2_malloc_type (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_identifier (32 samples, 0.07%)libsystem_platform.dylib`_platform_memmove (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (16 samples, 0.03%)libsystem_platform.dylib`_platform_memmove (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`sqlparser::dialect::Dialect::get_next_precedence_default (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::peek_token (7 samples, 0.01%)libsystem_malloc.dylib`_malloc_zone_malloc (6 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (7 samples, 0.01%)libsystem_malloc.dylib`nanov2_realloc (15 samples, 0.03%)libsystem_malloc.dylib`_malloc_zone_realloc (29 samples, 0.06%)libsystem_platform.dylib`_platform_memmove (7 samples, 0.01%)libsystem_malloc.dylib`_realloc (32 samples, 0.07%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (41 samples, 0.09%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVecInner<A>::reserve::do_reserve_and_handle (40 samples, 0.08%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (39 samples, 0.08%)libsystem_malloc.dylib`nanov2_size (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVecInner<A>::reserve::do_reserve_and_handle (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Location as core::fmt::Display>::fmt (70 samples, 0.15%)sqlparser_bench-959bc5267970ca34`core::fmt::write (68 samples, 0.14%)sqlparser_bench-959bc5267970ca34`core::fmt::num::imp::_<impl core::fmt::Display for u64>::fmt (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`alloc::fmt::format::format_inner (80 samples, 0.17%)sqlparser_bench-959bc5267970ca34`core::fmt::write (74 samples, 0.16%)libsystem_malloc.dylib`_nanov2_free (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::data_type::DataType> (11 samples, 0.02%)libsystem_platform.dylib`_platform_memmove (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_object_name (31 samples, 0.07%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_identifier (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_data_type_helper (44 samples, 0.09%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_data_type (49 samples, 0.10%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_expr_prefix_by_unreserved_word (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_prefix (200 samples, 0.42%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_comma_separated_with_trailing_commas (559 samples, 1.17%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_function_args (485 samples, 1.02%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_wildcard_expr (277 samples, 0.58%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_subexpr (243 samples, 0.51%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_function_argument_list (663 samples, 1.39%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_listagg_on_overflow (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_json_null_clause (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_function_call (723 samples, 1.52%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_listagg_on_overflow (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_expr_prefix_by_unreserved_word (766 samples, 1.61%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_prefix (1,085 samples, 2.28%)s..sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_select_item (1,285 samples, 2.70%)sq..sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_wildcard_expr (1,190 samples, 2.50%)sq..sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_subexpr (1,144 samples, 2.40%)sq..libsystem_malloc.dylib`_free (15 samples, 0.03%)libsystem_malloc.dylib`_nanov2_free (15 samples, 0.03%)libsystem_platform.dylib`_platform_memmove (45 samples, 0.09%)sqlparser_bench-959bc5267970ca34`<T as core::any::Any>::type_id (7 samples, 0.01%)libsystem_malloc.dylib`_malloc_zone_malloc (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (8 samples, 0.02%)libsystem_malloc.dylib`nanov2_malloc_type (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (29 samples, 0.06%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$free (8 samples, 0.02%)libsystem_malloc.dylib`_realloc (7 samples, 0.01%)libsystem_malloc.dylib`_malloc_zone_realloc (7 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVec<T,A>::grow_one (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::tokenizer::Token> (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_join_constraint (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_parenthesized_column_list (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_identifier (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_keyword (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_keywords (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_object_name (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_one_of_keywords (7 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (42 samples, 0.09%)sqlparser_bench-959bc5267970ca34`<T as core::any::Any>::type_id (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::cmp::PartialEq>::eq (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::tokenizer::Token> (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::maybe_parse_table_sample (6 samples, 0.01%)libsystem_malloc.dylib`_free (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$free (5 samples, 0.01%)libsystem_malloc.dylib`_malloc_zone_malloc (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVec<T,A>::grow_one (43 samples, 0.09%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (26 samples, 0.05%)libsystem_malloc.dylib`nanov2_malloc_type (25 samples, 0.05%)libsystem_malloc.dylib`nanov2_allocate_outlined (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (7 samples, 0.01%)libsystem_malloc.dylib`_malloc_zone_malloc (5 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (12 samples, 0.03%)libsystem_platform.dylib`_platform_memmove (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (23 samples, 0.05%)libsystem_malloc.dylib`nanov2_malloc_type (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (23 samples, 0.05%)libsystem_malloc.dylib`nanov2_malloc_type (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (37 samples, 0.08%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_object_name (231 samples, 0.49%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_identifier (147 samples, 0.31%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$free (6 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (8 samples, 0.02%)libsystem_platform.dylib`_platform_memmove (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (13 samples, 0.03%)libsystem_malloc.dylib`nanov2_malloc_type (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_optional_table_alias (100 samples, 0.21%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_optional_alias (82 samples, 0.17%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (37 samples, 0.08%)libsystem_malloc.dylib`_malloc_zone_malloc (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (15 samples, 0.03%)libsystem_malloc.dylib`nanov2_malloc_type (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::peek_token (40 samples, 0.08%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (33 samples, 0.07%)libsystem_malloc.dylib`_malloc_zone_malloc (15 samples, 0.03%)libsystem_platform.dylib`_platform_memmove (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (19 samples, 0.04%)libsystem_malloc.dylib`nanov2_malloc_type (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_table_factor (701 samples, 1.47%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::peek_tokens (177 samples, 0.37%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (65 samples, 0.14%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_table_version (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_table_and_joins (991 samples, 2.08%)s..sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_comma_separated_with_trailing_commas (2,665 samples, 5.60%)sqlpars..sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_infix (6 samples, 0.01%)libsystem_malloc.dylib`_malloc_zone_malloc (13 samples, 0.03%)libsystem_platform.dylib`_platform_memmove (85 samples, 0.18%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$memcpy (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`__rdl_alloc (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::tokenizer::Token> (8 samples, 0.02%)libsystem_malloc.dylib`_nanov2_free (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`sqlparser::dialect::Dialect::get_next_precedence_default (32 samples, 0.07%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::peek_token (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (14 samples, 0.03%)libsystem_malloc.dylib`rack_get_thread_index (8 samples, 0.02%)libsystem_malloc.dylib`tiny_malloc_from_free_list (8 samples, 0.02%)libsystem_malloc.dylib`set_tiny_meta_header_in_use (11 samples, 0.02%)libsystem_malloc.dylib`_tiny_check_and_zero_inline_meta_from_freelist (5 samples, 0.01%)libsystem_malloc.dylib`szone_malloc_should_clear (114 samples, 0.24%)libsystem_malloc.dylib`tiny_malloc_should_clear (81 samples, 0.17%)libsystem_malloc.dylib`tiny_malloc_from_free_list (53 samples, 0.11%)libsystem_malloc.dylib`tiny_free_list_add_ptr (5 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (23 samples, 0.05%)libsystem_malloc.dylib`_free (7 samples, 0.01%)libsystem_malloc.dylib`_malloc_zone_malloc (6 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (6 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (62 samples, 0.13%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$memcpy (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::tokenizer::Token> (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`sqlparser::dialect::Dialect::get_next_precedence_default (30 samples, 0.06%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::peek_token (20 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (12 samples, 0.03%)libsystem_malloc.dylib`set_tiny_meta_header_in_use (8 samples, 0.02%)libsystem_malloc.dylib`szone_malloc_should_clear (37 samples, 0.08%)libsystem_malloc.dylib`tiny_malloc_should_clear (36 samples, 0.08%)libsystem_malloc.dylib`tiny_malloc_from_free_list (25 samples, 0.05%)libsystem_malloc.dylib`_free (7 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (19 samples, 0.04%)libsystem_malloc.dylib`_nanov2_free (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::dialect::Dialect::get_next_precedence_default (25 samples, 0.05%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::peek_token (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (13 samples, 0.03%)libsystem_malloc.dylib`_nanov2_free (6 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (5 samples, 0.01%)libsystem_platform.dylib`_platform_memset (5 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVecInner<A>::reserve::do_reserve_and_handle (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (6 samples, 0.01%)libsystem_malloc.dylib`nanov2_malloc_type (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (13 samples, 0.03%)libsystem_platform.dylib`_platform_memmove (6 samples, 0.01%)libsystem_malloc.dylib`nanov2_realloc (9 samples, 0.02%)libsystem_malloc.dylib`_malloc_zone_realloc (18 samples, 0.04%)libsystem_malloc.dylib`_realloc (20 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (28 samples, 0.06%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVecInner<A>::reserve::do_reserve_and_handle (24 samples, 0.05%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (22 samples, 0.05%)libsystem_platform.dylib`_platform_memmove (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Location as core::fmt::Display>::fmt (57 samples, 0.12%)sqlparser_bench-959bc5267970ca34`core::fmt::write (55 samples, 0.12%)sqlparser_bench-959bc5267970ca34`core::fmt::num::imp::_<impl core::fmt::Display for u64>::fmt (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::pad (5 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::fmt::Display>::fmt (20 samples, 0.04%)sqlparser_bench-959bc5267970ca34`core::fmt::write (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_data_type (157 samples, 0.33%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_data_type_helper (155 samples, 0.33%)sqlparser_bench-959bc5267970ca34`alloc::fmt::format::format_inner (136 samples, 0.29%)sqlparser_bench-959bc5267970ca34`core::fmt::write (121 samples, 0.25%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_prefix (223 samples, 0.47%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_value (26 samples, 0.05%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_infix (338 samples, 0.71%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_subexpr (291 samples, 0.61%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_keyword (7 samples, 0.01%)libsystem_malloc.dylib`_malloc_zone_malloc (6 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (24 samples, 0.05%)libsystem_platform.dylib`_platform_memmove (8 samples, 0.02%)libsystem_platform.dylib`_platform_memset (8 samples, 0.02%)libsystem_platform.dylib`_platform_memmove (7 samples, 0.01%)libsystem_malloc.dylib`nanov2_pointer_size (5 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (10 samples, 0.02%)libsystem_malloc.dylib`nanov2_realloc (18 samples, 0.04%)libsystem_malloc.dylib`_malloc_zone_realloc (38 samples, 0.08%)libsystem_platform.dylib`_platform_memmove (7 samples, 0.01%)libsystem_malloc.dylib`_realloc (42 samples, 0.09%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVecInner<A>::reserve::do_reserve_and_handle (52 samples, 0.11%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (47 samples, 0.10%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (55 samples, 0.12%)libsystem_platform.dylib`_platform_memmove (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Location as core::fmt::Display>::fmt (85 samples, 0.18%)sqlparser_bench-959bc5267970ca34`core::fmt::write (84 samples, 0.18%)sqlparser_bench-959bc5267970ca34`core::fmt::num::imp::_<impl core::fmt::Display for u64>::fmt (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`alloc::fmt::format::format_inner (96 samples, 0.20%)sqlparser_bench-959bc5267970ca34`core::fmt::write (89 samples, 0.19%)libsystem_malloc.dylib`_nanov2_free (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::data_type::DataType> (11 samples, 0.02%)libsystem_platform.dylib`_platform_memset (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (5 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVecInner<A>::reserve::do_reserve_and_handle (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (15 samples, 0.03%)libsystem_platform.dylib`_platform_memmove (5 samples, 0.01%)libsystem_malloc.dylib`nanov2_pointer_size (7 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (9 samples, 0.02%)libsystem_malloc.dylib`nanov2_malloc (5 samples, 0.01%)libsystem_malloc.dylib`nanov2_realloc (21 samples, 0.04%)libsystem_malloc.dylib`_realloc (46 samples, 0.10%)libsystem_malloc.dylib`_malloc_zone_realloc (39 samples, 0.08%)libsystem_platform.dylib`_platform_memmove (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVecInner<A>::reserve::do_reserve_and_handle (63 samples, 0.13%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (57 samples, 0.12%)libsystem_malloc.dylib`nanov2_size (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (73 samples, 0.15%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::pad_integral (6 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::pad_integral::write_prefix (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Location as core::fmt::Display>::fmt (121 samples, 0.25%)sqlparser_bench-959bc5267970ca34`core::fmt::write (120 samples, 0.25%)sqlparser_bench-959bc5267970ca34`core::fmt::num::imp::_<impl core::fmt::Display for u64>::fmt (27 samples, 0.06%)sqlparser_bench-959bc5267970ca34`<&T as core::fmt::Display>::fmt (5 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::fmt::Display>::fmt (33 samples, 0.07%)sqlparser_bench-959bc5267970ca34`core::fmt::write (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$memcpy (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`alloc::fmt::format::format_inner (260 samples, 0.55%)sqlparser_bench-959bc5267970ca34`core::fmt::write (214 samples, 0.45%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVec<T,A>::grow_one (6 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (6 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (8 samples, 0.02%)libsystem_platform.dylib`_platform_memmove (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_object_name (63 samples, 0.13%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_identifier (49 samples, 0.10%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_data_type_helper (352 samples, 0.74%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_data_type (365 samples, 0.77%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_expr_prefix_by_unreserved_word (11 samples, 0.02%)libsystem_malloc.dylib`_nanov2_free (10 samples, 0.02%)libsystem_malloc.dylib`nanov2_malloc_type (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (6 samples, 0.01%)libsystem_malloc.dylib`nanov2_malloc_type (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_value (33 samples, 0.07%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_prefix (622 samples, 1.31%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_infix (1,318 samples, 2.77%)sq..sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_subexpr (1,147 samples, 2.41%)sq..sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_keyword (5 samples, 0.01%)libsystem_malloc.dylib`_malloc_zone_malloc (5 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (10 samples, 0.02%)libsystem_malloc.dylib`_free (7 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (9 samples, 0.02%)libsystem_platform.dylib`_platform_memset (5 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (23 samples, 0.05%)libsystem_malloc.dylib`_malloc_zone_malloc (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVecInner<A>::reserve::do_reserve_and_handle (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (20 samples, 0.04%)libsystem_platform.dylib`_platform_memmove (8 samples, 0.02%)libsystem_malloc.dylib`_nanov2_free (5 samples, 0.01%)libsystem_malloc.dylib`nanov2_malloc (7 samples, 0.01%)libsystem_malloc.dylib`nanov2_realloc (21 samples, 0.04%)libsystem_malloc.dylib`_malloc_zone_realloc (34 samples, 0.07%)libsystem_platform.dylib`_platform_memmove (8 samples, 0.02%)libsystem_malloc.dylib`_realloc (39 samples, 0.08%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (58 samples, 0.12%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVecInner<A>::reserve::do_reserve_and_handle (52 samples, 0.11%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (48 samples, 0.10%)libsystem_malloc.dylib`nanov2_size (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::pad_integral (14 samples, 0.03%)libsystem_platform.dylib`_platform_memmove (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::pad_integral::write_prefix (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Location as core::fmt::Display>::fmt (126 samples, 0.26%)sqlparser_bench-959bc5267970ca34`core::fmt::write (123 samples, 0.26%)sqlparser_bench-959bc5267970ca34`core::fmt::num::imp::_<impl core::fmt::Display for u64>::fmt (23 samples, 0.05%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (5 samples, 0.01%)libsystem_platform.dylib`_platform_memmove (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::fmt::Display>::fmt (31 samples, 0.07%)sqlparser_bench-959bc5267970ca34`core::fmt::write (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::pad (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`alloc::fmt::format::format_inner (245 samples, 0.51%)sqlparser_bench-959bc5267970ca34`core::fmt::write (224 samples, 0.47%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_data_type (281 samples, 0.59%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_data_type_helper (270 samples, 0.57%)libsystem_malloc.dylib`_nanov2_free (5 samples, 0.01%)libsystem_malloc.dylib`_malloc_zone_malloc (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_value (30 samples, 0.06%)sqlparser_bench-959bc5267970ca34`<sqlparser::tokenizer::Token as core::clone::Clone>::clone (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::clone::Clone>::clone (9 samples, 0.02%)libsystem_malloc.dylib`nanov2_malloc_type (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_prefix (365 samples, 0.77%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_subexpr (1,893 samples, 3.98%)sqlp..sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_query_body (5,198 samples, 10.92%)sqlparser_bench-..sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_select (4,878 samples, 10.24%)sqlparser_bench..sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_query (7,112 samples, 14.94%)sqlparser_bench-959bc52..sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_statements (7,412 samples, 15.57%)sqlparser_bench-959bc526..sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_statement (7,260 samples, 15.25%)sqlparser_bench-959bc52..sqlparser_bench-959bc5267970ca34`sqlparser::tokenizer::Tokenizer::next_token (136 samples, 0.29%)sqlparser_bench-959bc5267970ca34`sqlparser::tokenizer::Tokenizer::tokenize_identifier_or_keyword (26 samples, 0.05%)libsystem_malloc.dylib`_free (121 samples, 0.25%)libsystem_malloc.dylib`_nanov2_free (33 samples, 0.07%)libsystem_platform.dylib`_platform_memmove (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::iter::traits::collect::FromIterator<char>>::from_iter (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<sqlparser::dialect::generic::GenericDialect as sqlparser::dialect::Dialect>::is_delimited_identifier_start (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<sqlparser::dialect::mssql::MsSqlDialect as sqlparser::dialect::Dialect>::is_identifier_start (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$free (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$memcpy (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`__rdl_dealloc (5 samples, 0.01%)libsystem_malloc.dylib`_malloc_zone_malloc (11 samples, 0.02%)libsystem_malloc.dylib`_szone_free (5 samples, 0.01%)libsystem_malloc.dylib`free_medium (5 samples, 0.01%)libsystem_kernel.dylib`madvise (5 samples, 0.01%)libsystem_malloc.dylib`tiny_free_list_add_ptr (5 samples, 0.01%)libsystem_malloc.dylib`free_tiny (33 samples, 0.07%)libsystem_malloc.dylib`tiny_free_no_lock (27 samples, 0.06%)libsystem_malloc.dylib`tiny_free_list_remove_ptr (8 samples, 0.02%)libsystem_malloc.dylib`small_try_realloc_in_place (12 samples, 0.03%)libsystem_malloc.dylib`small_free_list_add_ptr (5 samples, 0.01%)libsystem_malloc.dylib`szone_malloc_should_clear (38 samples, 0.08%)libsystem_malloc.dylib`small_malloc_should_clear (27 samples, 0.06%)libsystem_malloc.dylib`small_malloc_from_free_list (23 samples, 0.05%)libsystem_malloc.dylib`small_free_list_remove_ptr_no_clear (8 samples, 0.02%)libsystem_malloc.dylib`szone_size (9 samples, 0.02%)libsystem_malloc.dylib`tiny_size (8 samples, 0.02%)libsystem_malloc.dylib`tiny_try_realloc_in_place (24 samples, 0.05%)libsystem_malloc.dylib`szone_realloc (166 samples, 0.35%)libsystem_platform.dylib`_platform_memset (10 samples, 0.02%)libsystem_malloc.dylib`_malloc_zone_realloc (223 samples, 0.47%)libsystem_platform.dylib`_platform_memmove (36 samples, 0.08%)libsystem_malloc.dylib`nanov2_realloc (6 samples, 0.01%)libsystem_malloc.dylib`szone_realloc (10 samples, 0.02%)libsystem_malloc.dylib`_realloc (297 samples, 0.62%)libsystem_malloc.dylib`szone_size (34 samples, 0.07%)libsystem_malloc.dylib`tiny_size (33 samples, 0.07%)libsystem_malloc.dylib`szone_malloc_should_clear (39 samples, 0.08%)libsystem_malloc.dylib`tiny_malloc_should_clear (31 samples, 0.07%)libsystem_malloc.dylib`tiny_malloc_from_free_list (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVec<T,A>::grow_one (401 samples, 0.84%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (358 samples, 0.75%)sqlparser_bench-959bc5267970ca34`sqlparser::tokenizer::State::next (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`sqlparser::tokenizer::State::peek (27 samples, 0.06%)sqlparser_bench-959bc5267970ca34`sqlparser::tokenizer::Tokenizer::consume_and_return (18 samples, 0.04%)libsystem_malloc.dylib`_malloc_zone_malloc (7 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (21 samples, 0.04%)libsystem_platform.dylib`_platform_memcmp (42 samples, 0.09%)libsystem_platform.dylib`_platform_memmove (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<sqlparser::dialect::mssql::MsSqlDialect as sqlparser::dialect::Dialect>::is_identifier_part (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$memcmp (15 samples, 0.03%)libsystem_malloc.dylib`_malloc_zone_malloc (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVec<T,A>::grow_one (36 samples, 0.08%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (10 samples, 0.02%)libsystem_malloc.dylib`nanov2_malloc_type (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`sqlparser::tokenizer::Token::make_word (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`alloc::str::_<impl str>::to_uppercase (6 samples, 0.01%)libsystem_malloc.dylib`_nanov2_free (5 samples, 0.01%)libsystem_malloc.dylib`nanov2_malloc_type (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVec<T,A>::grow_one (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`sqlparser::tokenizer::Tokenizer::next_token (641 samples, 1.35%)sqlparser_bench-959bc5267970ca34`sqlparser::tokenizer::Tokenizer::tokenize_word (61 samples, 0.13%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVecInner<A>::reserve::do_reserve_and_handle (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (7 samples, 0.01%)libsystem_malloc.dylib`_free (37 samples, 0.08%)libsystem_malloc.dylib`_malloc_zone_malloc (32 samples, 0.07%)libsystem_malloc.dylib`_nanov2_free (214 samples, 0.45%)libsystem_platform.dylib`_platform_memcmp (527 samples, 1.11%)libsystem_platform.dylib`_platform_memmove (89 samples, 0.19%)libsystem_malloc.dylib`_malloc_zone_malloc (37 samples, 0.08%)sqlparser_bench-959bc5267970ca34`__rdl_alloc (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVecInner<A>::reserve::do_reserve_and_handle (136 samples, 0.29%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (63 samples, 0.13%)libsystem_malloc.dylib`nanov2_malloc_type (48 samples, 0.10%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::iter::traits::collect::FromIterator<char>>::from_iter (201 samples, 0.42%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<sqlparser::dialect::mssql::MsSqlDialect as sqlparser::dialect::Dialect>::is_identifier_part (105 samples, 0.22%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$free (23 samples, 0.05%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$malloc (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$memcmp (176 samples, 0.37%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$memcpy (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`__rdl_alloc (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVec<T,A>::grow_one (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVecInner<A>::reserve::do_reserve_and_handle (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`alloc::str::_<impl str>::to_uppercase (27 samples, 0.06%)libsystem_malloc.dylib`_malloc_zone_malloc (37 samples, 0.08%)libsystem_malloc.dylib`nanov2_malloc_type (57 samples, 0.12%)libsystem_malloc.dylib`nanov2_allocate_outlined (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$malloc (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`__rdl_alloc (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`sqlparser::tokenizer::Token::make_word (300 samples, 0.63%)sqlparser_bench-959bc5267970ca34`alloc::str::_<impl str>::to_uppercase (111 samples, 0.23%)libsystem_malloc.dylib`nanov2_malloc_type (57 samples, 0.12%)libsystem_malloc.dylib`_nanov2_free (68 samples, 0.14%)libsystem_malloc.dylib`_malloc_zone_malloc (31 samples, 0.07%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$malloc (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`__rdl_alloc (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVec<T,A>::grow_one (149 samples, 0.31%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (72 samples, 0.15%)libsystem_malloc.dylib`nanov2_malloc_type (55 samples, 0.12%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVecInner<A>::reserve::do_reserve_and_handle (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::tokenizer::Tokenizer::tokenize_identifier_or_keyword (2,345 samples, 4.92%)sqlpar..sqlparser_bench-959bc5267970ca34`sqlparser::tokenizer::Tokenizer::tokenize_word (492 samples, 1.03%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`sqlparser::tokenizer::Tokenizer::tokenize_with_location (4,225 samples, 8.87%)sqlparser_ben..sqlparser_bench-959bc5267970ca34`sqlparser::tokenizer::Tokenizer::tokenize_with_location_into_buf (4,059 samples, 8.52%)sqlparser_be..sqlparser_bench-959bc5267970ca34`sqlparser::tokenizer::Tokenizer::tokenize_word (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::try_with_sql (4,258 samples, 8.94%)sqlparser_ben..sqlparser_bench-959bc5267970ca34`sqlparser::tokenizer::Tokenizer::tokenize_with_location_into_buf (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_sql (12,017 samples, 25.24%)sqlparser_bench-959bc5267970ca34`sqlpars..sqlparser_bench-959bc5267970ca34`criterion::bencher::Bencher<M>::iter (16,292 samples, 34.21%)sqlparser_bench-959bc5267970ca34`criterion::bencher::Be..sqlparser_bench-959bc5267970ca34`criterion::benchmark_group::BenchmarkGroup<M>::bench_function (35,307 samples, 74.15%)sqlparser_bench-959bc5267970ca34`criterion::benchmark_group::BenchmarkGroup<M>::bench_functionsqlparser_bench-959bc5267970ca34`criterion::analysis::common (35,307 samples, 74.15%)sqlparser_bench-959bc5267970ca34`criterion::analysis::commonsqlparser_bench-959bc5267970ca34`criterion::routine::Routine::sample (35,254 samples, 74.04%)sqlparser_bench-959bc5267970ca34`criterion::routine::Routine::samplesqlparser_bench-959bc5267970ca34`<criterion::routine::Function<M,F,T> as criterion::routine::Routine<M,T>>::warm_up (16,308 samples, 34.25%)sqlparser_bench-959bc5267970ca34`<criterion::routine::Fu..dyld`start (35,315 samples, 74.16%)dyld`startsqlparser_bench-959bc5267970ca34`main (35,314 samples, 74.16%)sqlparser_bench-959bc5267970ca34`mainsqlparser_bench-959bc5267970ca34`std::rt::lang_start_internal (35,314 samples, 74.16%)sqlparser_bench-959bc5267970ca34`std::rt::lang_start_internalsqlparser_bench-959bc5267970ca34`std::rt::lang_start::_{{closure}} (35,314 samples, 74.16%)sqlparser_bench-959bc5267970ca34`std::rt::lang_start::_{{closure}}sqlparser_bench-959bc5267970ca34`std::sys::backtrace::__rust_begin_short_backtrace (35,314 samples, 74.16%)sqlparser_bench-959bc5267970ca34`std::sys::backtrace::__rust_begin_short_backtracesqlparser_bench-959bc5267970ca34`sqlparser_bench::main (35,314 samples, 74.16%)sqlparser_bench-959bc5267970ca34`sqlparser_bench::mainsqlparser_bench-959bc5267970ca34`sqlparser::parser::Parser::parse_sql (5 samples, 0.01%)libsystem_kernel.dylib`swtch_pri (133 samples, 0.28%)libsystem_m.dylib`exp (23 samples, 0.05%)libsystem_m.dylib`exp (43 samples, 0.09%)libsystem_m.dylib`exp (47 samples, 0.10%)libsystem_m.dylib`exp (46 samples, 0.10%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::Producer::fold_with (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ops::function::impls::_<impl core::ops::function::Fn<A> for &F>::call (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::analysis::compare::estimates::stats (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$exp (8 samples, 0.02%)libsystem_m.dylib`exp (57 samples, 0.12%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::analysis::compare::estimates::stats (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::Producer::fold_with (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`core::ops::function::impls::_<impl core::ops::function::Fn<A> for &F>::call (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$exp (6 samples, 0.01%)libsystem_m.dylib`exp (37 samples, 0.08%)sqlparser_bench-959bc5267970ca34`criterion::analysis::compare::estimates::stats (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::Producer::fold_with (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ops::function::impls::_<impl core::ops::function::Fn<A> for &F>::call (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$exp (5 samples, 0.01%)libsystem_m.dylib`exp (40 samples, 0.08%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::resamples::Resamples<A>::next (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`core::ops::function::impls::_<impl core::ops::function::Fn<A> for &F>::call (108 samples, 0.23%)sqlparser_bench-959bc5267970ca34`oorandom::Rand64::rand_range (71 samples, 0.15%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::median_abs_dev (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::analysis::estimates::stats (32 samples, 0.07%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::stats::bivariate::resamples::Resamples<X,Y>::next (30 samples, 0.06%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (224 samples, 0.47%)sqlparser_bench-959bc5267970ca34`oorandom::Rand64::rand_range (45 samples, 0.09%)sqlparser_bench-959bc5267970ca34`criterion::analysis::compare::estimates::stats (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (283 samples, 0.59%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::Producer::fold_with (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::ops::function::impls::_<impl core::ops::function::Fn<A> for &F>::call (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$exp (12 samples, 0.03%)libsystem_m.dylib`exp (61 samples, 0.13%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::median_abs_dev (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`criterion::analysis::estimates::stats (35 samples, 0.07%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (41 samples, 0.09%)sqlparser_bench-959bc5267970ca34`oorandom::Rand64::rand_range (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::analysis::compare::estimates::stats (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (134 samples, 0.28%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (121 samples, 0.25%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::Producer::fold_with (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ops::function::impls::_<impl core::ops::function::Fn<A> for &F>::call (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (492 samples, 1.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (440 samples, 0.92%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (9 samples, 0.02%)libsystem_m.dylib`exp (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::Producer::fold_with (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ops::function::impls::_<impl core::ops::function::Fn<A> for &F>::call (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::analysis::compare::estimates::stats (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$exp (11 samples, 0.02%)libsystem_m.dylib`exp (70 samples, 0.15%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::median_abs_dev (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`criterion::analysis::estimates::stats (24 samples, 0.05%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (31 samples, 0.07%)sqlparser_bench-959bc5267970ca34`oorandom::Rand64::rand_range (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (126 samples, 0.26%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::Producer::fold_with (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ops::function::impls::_<impl core::ops::function::Fn<A> for &F>::call (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$exp (9 samples, 0.02%)libsystem_m.dylib`exp (62 samples, 0.13%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::median_abs_dev (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::analysis::estimates::stats (33 samples, 0.07%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (38 samples, 0.08%)sqlparser_bench-959bc5267970ca34`oorandom::Rand64::rand_range (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (137 samples, 0.29%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (125 samples, 0.26%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::Producer::fold_with (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ops::function::impls::_<impl core::ops::function::Fn<A> for &F>::call (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::analysis::compare::estimates::stats (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (311 samples, 0.65%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (309 samples, 0.65%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (284 samples, 0.60%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (22 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (943 samples, 1.98%)s..sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (860 samples, 1.81%)s..sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (51 samples, 0.11%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (50 samples, 0.11%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (50 samples, 0.11%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (49 samples, 0.10%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (24 samples, 0.05%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (24 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (24 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (24 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$exp (6 samples, 0.01%)libsystem_m.dylib`exp (35 samples, 0.07%)sqlparser_bench-959bc5267970ca34`criterion::analysis::compare::estimates::stats (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::Producer::fold_with (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`core::ops::function::impls::_<impl core::ops::function::Fn<A> for &F>::call (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$exp (6 samples, 0.01%)libsystem_m.dylib`exp (37 samples, 0.08%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::Producer::fold_with (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::ops::function::impls::_<impl core::ops::function::Fn<A> for &F>::call (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`criterion::analysis::compare::estimates::stats (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$exp (7 samples, 0.01%)libsystem_m.dylib`exp (57 samples, 0.12%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::median_abs_dev (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::analysis::estimates::stats (30 samples, 0.06%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (34 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (105 samples, 0.22%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$exp (8 samples, 0.02%)libsystem_m.dylib`exp (55 samples, 0.12%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::median_abs_dev (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`criterion::analysis::estimates::stats (24 samples, 0.05%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (31 samples, 0.07%)sqlparser_bench-959bc5267970ca34`oorandom::Rand64::rand_range (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (115 samples, 0.24%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (106 samples, 0.22%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (278 samples, 0.58%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (229 samples, 0.48%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$exp (6 samples, 0.01%)libsystem_m.dylib`exp (37 samples, 0.08%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$exp (6 samples, 0.01%)libsystem_m.dylib`exp (56 samples, 0.12%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::median_abs_dev (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::analysis::estimates::stats (29 samples, 0.06%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (32 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (103 samples, 0.22%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::Producer::fold_with (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ops::function::impls::_<impl core::ops::function::Fn<A> for &F>::call (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$exp (6 samples, 0.01%)libsystem_m.dylib`exp (52 samples, 0.11%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::median_abs_dev (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::analysis::estimates::stats (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (23 samples, 0.05%)sqlparser_bench-959bc5267970ca34`criterion::analysis::compare::estimates::stats (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (104 samples, 0.22%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (96 samples, 0.20%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::Producer::fold_with (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`core::ops::function::impls::_<impl core::ops::function::Fn<A> for &F>::call (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (276 samples, 0.58%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (270 samples, 0.57%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (228 samples, 0.48%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (653 samples, 1.37%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (647 samples, 1.36%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (592 samples, 1.24%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (30 samples, 0.06%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (30 samples, 0.06%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (30 samples, 0.06%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (30 samples, 0.06%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::stats::bivariate::resamples::Resamples<X,Y>::next (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (22 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (34 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (32 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (55 samples, 0.12%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (55 samples, 0.12%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)libsystem_m.dylib`exp (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (24 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (24 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (104 samples, 0.22%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (100 samples, 0.21%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (20 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (35 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (35 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (34 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (1,836 samples, 3.86%)sqlp..sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (1,775 samples, 3.73%)sqlp..sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (169 samples, 0.35%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (168 samples, 0.35%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (168 samples, 0.35%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (166 samples, 0.35%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (27 samples, 0.06%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (27 samples, 0.06%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (27 samples, 0.06%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (25 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$exp (5 samples, 0.01%)libsystem_m.dylib`exp (33 samples, 0.07%)sqlparser_bench-959bc5267970ca34`criterion::analysis::compare::estimates::stats (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::Producer::fold_with (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::ops::function::impls::_<impl core::ops::function::Fn<A> for &F>::call (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$exp (13 samples, 0.03%)libsystem_m.dylib`exp (32 samples, 0.07%)sqlparser_bench-959bc5267970ca34`criterion::analysis::compare::estimates::stats (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::Producer::fold_with (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ops::function::impls::_<impl core::ops::function::Fn<A> for &F>::call (7 samples, 0.01%)libsystem_m.dylib`exp (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`criterion::analysis::compare::estimates::stats (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::Producer::fold_with (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ops::function::impls::_<impl core::ops::function::Fn<A> for &F>::call (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$exp (6 samples, 0.01%)libsystem_m.dylib`exp (27 samples, 0.06%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::median_abs_dev (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`criterion::analysis::estimates::stats (20 samples, 0.04%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (55 samples, 0.12%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$exp (7 samples, 0.01%)libsystem_m.dylib`exp (31 samples, 0.07%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::median_abs_dev (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`criterion::analysis::estimates::stats (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (159 samples, 0.33%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (123 samples, 0.26%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (62 samples, 0.13%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (54 samples, 0.11%)libsystem_m.dylib`exp (30 samples, 0.06%)libsystem_m.dylib`exp (38 samples, 0.08%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::median_abs_dev (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::analysis::estimates::stats (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (60 samples, 0.13%)libsystem_m.dylib`exp (31 samples, 0.07%)sqlparser_bench-959bc5267970ca34`criterion::analysis::estimates::stats (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (54 samples, 0.11%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (50 samples, 0.11%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (169 samples, 0.35%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (167 samples, 0.35%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (129 samples, 0.27%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (22 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (408 samples, 0.86%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (364 samples, 0.76%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (34 samples, 0.07%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (34 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (34 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (32 samples, 0.07%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$exp (8 samples, 0.02%)libsystem_m.dylib`exp (29 samples, 0.06%)libsystem_m.dylib`exp (25 samples, 0.05%)sqlparser_bench-959bc5267970ca34`criterion::analysis::compare::estimates::stats (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::Producer::fold_with (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`core::ops::function::impls::_<impl core::ops::function::Fn<A> for &F>::call (13 samples, 0.03%)libsystem_m.dylib`exp (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::median_abs_dev (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::analysis::estimates::stats (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (46 samples, 0.10%)libsystem_m.dylib`exp (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::median_abs_dev (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::analysis::estimates::stats (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (129 samples, 0.27%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (88 samples, 0.18%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (39 samples, 0.08%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (35 samples, 0.07%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$exp (5 samples, 0.01%)libsystem_m.dylib`exp (25 samples, 0.05%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::analysis::compare::estimates::stats (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::Producer::fold_with (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`core::ops::function::impls::_<impl core::ops::function::Fn<A> for &F>::call (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$exp (6 samples, 0.01%)libsystem_m.dylib`exp (22 samples, 0.05%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::median_abs_dev (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::analysis::estimates::stats (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (41 samples, 0.09%)libsystem_m.dylib`exp (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`criterion::analysis::estimates::stats (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (35 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (33 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::Producer::fold_with (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ops::function::impls::_<impl core::ops::function::Fn<A> for &F>::call (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::analysis::compare::estimates::stats (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (142 samples, 0.30%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (136 samples, 0.29%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (96 samples, 0.20%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (32 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (30 samples, 0.06%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (375 samples, 0.79%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (367 samples, 0.77%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (332 samples, 0.70%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (57 samples, 0.12%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (57 samples, 0.12%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (57 samples, 0.12%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (55 samples, 0.12%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (29 samples, 0.06%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (24 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (37 samples, 0.08%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (37 samples, 0.08%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (36 samples, 0.08%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (73 samples, 0.15%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (72 samples, 0.15%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (23 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (22 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (22 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (32 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (32 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (31 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (147 samples, 0.31%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (147 samples, 0.31%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (143 samples, 0.30%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (38 samples, 0.08%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (38 samples, 0.08%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (38 samples, 0.08%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (36 samples, 0.08%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (1,005 samples, 2.11%)s..sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (998 samples, 2.10%)s..sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (945 samples, 1.98%)s..sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (148 samples, 0.31%)libsystem_m.dylib`exp (9 samples, 0.02%)libsystem_m.dylib`exp (6 samples, 0.01%)libsystem_m.dylib`exp (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ops::function::impls::_<impl core::ops::function::Fn<A> for &F>::call (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`oorandom::Rand64::rand_range (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (34 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (31 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)libsystem_m.dylib`exp (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (20 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (58 samples, 0.12%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (55 samples, 0.12%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (39 samples, 0.08%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (39 samples, 0.08%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (34 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (114 samples, 0.24%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (107 samples, 0.22%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (9 samples, 0.02%)libsystem_m.dylib`exp (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)libsystem_m.dylib`exp (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (49 samples, 0.10%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (47 samples, 0.10%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (38 samples, 0.08%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (185 samples, 0.39%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (178 samples, 0.37%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)libsystem_m.dylib`exp (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (20 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (75 samples, 0.16%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (75 samples, 0.16%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (71 samples, 0.15%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (40 samples, 0.08%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (40 samples, 0.08%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (40 samples, 0.08%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (39 samples, 0.08%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (24 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (51 samples, 0.11%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (48 samples, 0.10%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (23 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (23 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (22 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (3,267 samples, 6.86%)sqlparser..sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (3,209 samples, 6.74%)sqlparser..sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (364 samples, 0.76%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (362 samples, 0.76%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (360 samples, 0.76%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (348 samples, 0.73%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (87 samples, 0.18%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (87 samples, 0.18%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (86 samples, 0.18%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (82 samples, 0.17%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (24 samples, 0.05%)libsystem_m.dylib`exp (33 samples, 0.07%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$exp (5 samples, 0.01%)libsystem_m.dylib`exp (40 samples, 0.08%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::Producer::fold_with (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::ops::function::impls::_<impl core::ops::function::Fn<A> for &F>::call (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`criterion::analysis::compare::estimates::stats (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (7 samples, 0.01%)libsystem_m.dylib`exp (20 samples, 0.04%)sqlparser_bench-959bc5267970ca34`criterion::analysis::compare::estimates::stats (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::Producer::fold_with (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::ops::function::impls::_<impl core::ops::function::Fn<A> for &F>::call (9 samples, 0.02%)libsystem_m.dylib`exp (15 samples, 0.03%)libsystem_m.dylib`exp (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`criterion::analysis::estimates::stats (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (8 samples, 0.02%)libsystem_m.dylib`exp (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::median_abs_dev (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (61 samples, 0.13%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (44 samples, 0.09%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (23 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (20 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`criterion::analysis::estimates::stats (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$exp (5 samples, 0.01%)libsystem_m.dylib`exp (14 samples, 0.03%)libsystem_m.dylib`exp (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::median_abs_dev (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::analysis::estimates::stats (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (29 samples, 0.06%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (13 samples, 0.03%)libsystem_m.dylib`exp (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::median_abs_dev (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (177 samples, 0.37%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (142 samples, 0.30%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (79 samples, 0.17%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (74 samples, 0.16%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (51 samples, 0.11%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (20 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`criterion::analysis::estimates::stats (11 samples, 0.02%)libsystem_m.dylib`exp (28 samples, 0.06%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::Producer::fold_with (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ops::function::impls::_<impl core::ops::function::Fn<A> for &F>::call (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::analysis::compare::estimates::stats (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (5 samples, 0.01%)libsystem_m.dylib`exp (19 samples, 0.04%)libsystem_m.dylib`exp (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`criterion::analysis::estimates::stats (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (20 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (8 samples, 0.02%)libsystem_m.dylib`exp (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`criterion::analysis::estimates::stats (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (20 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (20 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (74 samples, 0.16%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (47 samples, 0.10%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)libsystem_m.dylib`exp (15 samples, 0.03%)libsystem_m.dylib`exp (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`criterion::analysis::estimates::stats (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (25 samples, 0.05%)libsystem_m.dylib`exp (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::analysis::estimates::stats (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (23 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (73 samples, 0.15%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (69 samples, 0.14%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (50 samples, 0.11%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (223 samples, 0.47%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (219 samples, 0.46%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (183 samples, 0.38%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (36 samples, 0.08%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (36 samples, 0.08%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (36 samples, 0.08%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (36 samples, 0.08%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (466 samples, 0.98%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (409 samples, 0.86%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)libsystem_m.dylib`exp (52 samples, 0.11%)libsystem_m.dylib`exp (31 samples, 0.07%)sqlparser_bench-959bc5267970ca34`criterion::analysis::compare::estimates::stats (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::Producer::fold_with (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::ops::function::impls::_<impl core::ops::function::Fn<A> for &F>::call (9 samples, 0.02%)libsystem_m.dylib`exp (19 samples, 0.04%)libsystem_m.dylib`exp (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::analysis::estimates::stats (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (50 samples, 0.11%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (27 samples, 0.06%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (11 samples, 0.02%)libsystem_m.dylib`exp (12 samples, 0.03%)libsystem_m.dylib`exp (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::median_abs_dev (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::analysis::estimates::stats (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (22 samples, 0.05%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (12 samples, 0.03%)libsystem_m.dylib`exp (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (150 samples, 0.32%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (105 samples, 0.22%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (55 samples, 0.12%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (55 samples, 0.12%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (39 samples, 0.08%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::analysis::estimates::stats (7 samples, 0.01%)libsystem_m.dylib`exp (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::Producer::fold_with (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::ops::function::impls::_<impl core::ops::function::Fn<A> for &F>::call (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`criterion::analysis::compare::estimates::stats (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (5 samples, 0.01%)libsystem_m.dylib`exp (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`criterion::analysis::compare::estimates::stats (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::Producer::fold_with (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::ops::function::impls::_<impl core::ops::function::Fn<A> for &F>::call (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::analysis::estimates::stats (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::analysis::estimates::stats (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (41 samples, 0.09%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (8 samples, 0.02%)libsystem_m.dylib`exp (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::Producer::fold_with (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ops::function::impls::_<impl core::ops::function::Fn<A> for &F>::call (5 samples, 0.01%)libsystem_m.dylib`exp (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::analysis::estimates::stats (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (47 samples, 0.10%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (45 samples, 0.09%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (22 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (145 samples, 0.30%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (141 samples, 0.30%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (113 samples, 0.24%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (23 samples, 0.05%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (23 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (23 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (22 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (30 samples, 0.06%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (29 samples, 0.06%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (25 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (25 samples, 0.05%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (71 samples, 0.15%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (71 samples, 0.15%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (70 samples, 0.15%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (31 samples, 0.07%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (31 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (31 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (29 samples, 0.06%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (435 samples, 0.91%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (431 samples, 0.91%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (370 samples, 0.78%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (72 samples, 0.15%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (27 samples, 0.06%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (25 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (27 samples, 0.06%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (26 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (23 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (88 samples, 0.18%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (81 samples, 0.17%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (26 samples, 0.05%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (26 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (26 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (24 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (35 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (35 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (34 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (1,110 samples, 2.33%)s..sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (1,106 samples, 2.32%)s..sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (1,064 samples, 2.23%)s..sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (156 samples, 0.33%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (155 samples, 0.33%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (155 samples, 0.33%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (153 samples, 0.32%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (30 samples, 0.06%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (30 samples, 0.06%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (29 samples, 0.06%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (28 samples, 0.06%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)libsystem_kernel.dylib`swtch_pri (5 samples, 0.01%)libsystem_m.dylib`exp (12 samples, 0.03%)libsystem_m.dylib`exp (11 samples, 0.02%)libsystem_m.dylib`exp (14 samples, 0.03%)libsystem_m.dylib`exp (10 samples, 0.02%)libsystem_m.dylib`exp (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::ops::function::impls::_<impl core::ops::function::Fn<A> for &F>::call (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`oorandom::Rand64::rand_range (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`criterion::analysis::estimates::stats (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (23 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (25 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (30 samples, 0.06%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (28 samples, 0.06%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (56 samples, 0.12%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (45 samples, 0.09%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$exp (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (31 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (25 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (20 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (103 samples, 0.22%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (91 samples, 0.19%)libsystem_m.dylib`exp (6 samples, 0.01%)libsystem_m.dylib`exp (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (28 samples, 0.06%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (54 samples, 0.11%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (52 samples, 0.11%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (46 samples, 0.10%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (194 samples, 0.41%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (178 samples, 0.37%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)libsystem_m.dylib`exp (10 samples, 0.02%)libsystem_m.dylib`exp (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (25 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (17 samples, 0.04%)libsystem_m.dylib`exp (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (52 samples, 0.11%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (47 samples, 0.10%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (24 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (49 samples, 0.10%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (47 samples, 0.10%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (41 samples, 0.09%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (129 samples, 0.27%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (128 samples, 0.27%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (117 samples, 0.25%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (385 samples, 0.81%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (369 samples, 0.77%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (45 samples, 0.09%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (44 samples, 0.09%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (44 samples, 0.09%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (42 samples, 0.09%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (22 samples, 0.05%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)libsystem_m.dylib`exp (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (47 samples, 0.10%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (41 samples, 0.09%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (8 samples, 0.02%)libsystem_m.dylib`exp (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (28 samples, 0.06%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (27 samples, 0.06%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (24 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (25 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (25 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (44 samples, 0.09%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (44 samples, 0.09%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (136 samples, 0.29%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (136 samples, 0.29%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (132 samples, 0.28%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (56 samples, 0.12%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (56 samples, 0.12%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (56 samples, 0.12%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (55 samples, 0.12%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)libsystem_m.dylib`exp (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (36 samples, 0.08%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (32 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (70 samples, 0.15%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (64 samples, 0.13%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (32 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (32 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (44 samples, 0.09%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (43 samples, 0.09%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (39 samples, 0.08%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (142 samples, 0.30%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (140 samples, 0.29%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (133 samples, 0.28%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (45 samples, 0.09%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (684 samples, 1.44%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (681 samples, 1.43%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (667 samples, 1.40%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (145 samples, 0.30%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (690 samples, 1.45%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5,126 samples, 10.77%)sqlparser_bench-..sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5,072 samples, 10.65%)sqlparser_bench-..libsystem_m.dylib`exp (24 samples, 0.05%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$exp (7 samples, 0.01%)libsystem_m.dylib`exp (18 samples, 0.04%)libsystem_m.dylib`exp (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::Producer::fold_with (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ops::function::impls::_<impl core::ops::function::Fn<A> for &F>::call (5 samples, 0.01%)libsystem_m.dylib`exp (6 samples, 0.01%)libsystem_m.dylib`exp (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)libsystem_m.dylib`exp (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (37 samples, 0.08%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (28 samples, 0.06%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (8 samples, 0.02%)libsystem_m.dylib`exp (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::Producer::fold_with (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ops::function::impls::_<impl core::ops::function::Fn<A> for &F>::call (5 samples, 0.01%)libsystem_m.dylib`exp (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::analysis::estimates::stats (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::analysis::estimates::stats (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (55 samples, 0.12%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (55 samples, 0.12%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (38 samples, 0.08%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (124 samples, 0.26%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (95 samples, 0.20%)libsystem_m.dylib`exp (18 samples, 0.04%)libsystem_m.dylib`exp (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (41 samples, 0.09%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (25 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)libsystem_m.dylib`exp (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::analysis::estimates::stats (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (38 samples, 0.08%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (37 samples, 0.08%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (34 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (112 samples, 0.24%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (109 samples, 0.23%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (86 samples, 0.18%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (285 samples, 0.60%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (260 samples, 0.55%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (22 samples, 0.05%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (22 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (22 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (20 samples, 0.04%)libsystem_m.dylib`exp (23 samples, 0.05%)libsystem_m.dylib`exp (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::Producer::fold_with (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ops::function::impls::_<impl core::ops::function::Fn<A> for &F>::call (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::analysis::compare::estimates::stats (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)libsystem_m.dylib`exp (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (75 samples, 0.16%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (50 samples, 0.11%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (29 samples, 0.06%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (29 samples, 0.06%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (8 samples, 0.02%)libsystem_m.dylib`exp (7 samples, 0.01%)libsystem_m.dylib`exp (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (20 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (20 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (72 samples, 0.15%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (69 samples, 0.14%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (57 samples, 0.12%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (20 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (20 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (20 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (20 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (32 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (31 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (26 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (26 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (25 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (60 samples, 0.13%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (59 samples, 0.12%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (25 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (25 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (25 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (276 samples, 0.58%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (272 samples, 0.57%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (248 samples, 0.52%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (99 samples, 0.21%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (99 samples, 0.21%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (99 samples, 0.21%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (99 samples, 0.21%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)libsystem_m.dylib`exp (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (33 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (30 samples, 0.06%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (22 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (43 samples, 0.09%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (43 samples, 0.09%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (38 samples, 0.08%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (86 samples, 0.18%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (84 samples, 0.18%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (27 samples, 0.06%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (27 samples, 0.06%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (24 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (159 samples, 0.33%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (155 samples, 0.33%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (39 samples, 0.08%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (39 samples, 0.08%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (39 samples, 0.08%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (38 samples, 0.08%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (37 samples, 0.08%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (37 samples, 0.08%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (33 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (24 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (20 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (44 samples, 0.09%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (43 samples, 0.09%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (880 samples, 1.85%)s..sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (878 samples, 1.84%)s..sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (847 samples, 1.78%)s..sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (279 samples, 0.59%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (278 samples, 0.58%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (278 samples, 0.58%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (269 samples, 0.56%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (72 samples, 0.15%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (72 samples, 0.15%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (71 samples, 0.15%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (69 samples, 0.14%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)libsystem_kernel.dylib`swtch_pri (12 samples, 0.03%)libsystem_m.dylib`exp (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::Producer::fold_with (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ops::function::impls::_<impl core::ops::function::Fn<A> for &F>::call (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::analysis::compare::estimates::stats (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (5 samples, 0.01%)libsystem_m.dylib`exp (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::Producer::fold_with (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ops::function::impls::_<impl core::ops::function::Fn<A> for &F>::call (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::analysis::compare::estimates::stats (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (6 samples, 0.01%)libsystem_m.dylib`exp (17 samples, 0.04%)libsystem_m.dylib`exp (17 samples, 0.04%)libsystem_m.dylib`exp (20 samples, 0.04%)libsystem_m.dylib`exp (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ops::function::impls::_<impl core::ops::function::Fn<A> for &F>::call (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`oorandom::Rand64::rand_range (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (34 samples, 0.07%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (32 samples, 0.07%)sqlparser_bench-959bc5267970ca34`oorandom::Rand64::rand_range (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (51 samples, 0.11%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (43 samples, 0.09%)libsystem_m.dylib`exp (5 samples, 0.01%)libsystem_m.dylib`exp (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::analysis::estimates::stats (5 samples, 0.01%)libsystem_m.dylib`exp (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (34 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (34 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (28 samples, 0.06%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (112 samples, 0.24%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (88 samples, 0.18%)libsystem_m.dylib`exp (15 samples, 0.03%)libsystem_m.dylib`exp (6 samples, 0.01%)libsystem_m.dylib`exp (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (32 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (25 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::analysis::estimates::stats (5 samples, 0.01%)libsystem_m.dylib`exp (9 samples, 0.02%)libsystem_m.dylib`exp (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (15 samples, 0.03%)libsystem_m.dylib`exp (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (44 samples, 0.09%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (42 samples, 0.09%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (30 samples, 0.06%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (107 samples, 0.22%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (104 samples, 0.22%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (83 samples, 0.17%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (241 samples, 0.51%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (221 samples, 0.46%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$exp (5 samples, 0.01%)libsystem_m.dylib`exp (15 samples, 0.03%)libsystem_m.dylib`exp (13 samples, 0.03%)libsystem_m.dylib`exp (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (20 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)libsystem_m.dylib`exp (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (66 samples, 0.14%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (50 samples, 0.11%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (30 samples, 0.06%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (28 samples, 0.06%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (23 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::analysis::estimates::stats (6 samples, 0.01%)libsystem_m.dylib`exp (10 samples, 0.02%)libsystem_m.dylib`exp (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (20 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)libsystem_m.dylib`exp (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (23 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (62 samples, 0.13%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (62 samples, 0.13%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (49 samples, 0.10%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (23 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (188 samples, 0.39%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (183 samples, 0.38%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (164 samples, 0.34%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (34 samples, 0.07%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (34 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (34 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (34 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (485 samples, 1.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (463 samples, 0.97%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (33 samples, 0.07%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (32 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (32 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (31 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (13 samples, 0.03%)libsystem_m.dylib`exp (14 samples, 0.03%)libsystem_m.dylib`exp (12 samples, 0.03%)libsystem_m.dylib`exp (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (32 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (20 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)libsystem_m.dylib`exp (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (8 samples, 0.02%)libsystem_m.dylib`exp (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (84 samples, 0.18%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (70 samples, 0.15%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (38 samples, 0.08%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (35 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (26 samples, 0.05%)libsystem_m.dylib`exp (13 samples, 0.03%)libsystem_m.dylib`exp (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (24 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (72 samples, 0.15%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (69 samples, 0.14%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (55 samples, 0.12%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (30 samples, 0.06%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (30 samples, 0.06%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (231 samples, 0.49%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (227 samples, 0.48%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (211 samples, 0.44%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (53 samples, 0.11%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (53 samples, 0.11%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (52 samples, 0.11%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (52 samples, 0.11%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)libsystem_m.dylib`exp (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (20 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (52 samples, 0.11%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (48 samples, 0.10%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (28 samples, 0.06%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (28 samples, 0.06%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (27 samples, 0.06%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (90 samples, 0.19%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (86 samples, 0.18%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (32 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (31 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (30 samples, 0.06%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (26 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (25 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (922 samples, 1.94%)s..sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (896 samples, 1.88%)s..sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (178 samples, 0.37%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (176 samples, 0.37%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (176 samples, 0.37%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (169 samples, 0.35%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (46 samples, 0.10%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (46 samples, 0.10%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (45 samples, 0.09%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (43 samples, 0.09%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (13 samples, 0.03%)libsystem_m.dylib`exp (7 samples, 0.01%)libsystem_m.dylib`exp (5 samples, 0.01%)libsystem_m.dylib`exp (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (34 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (28 samples, 0.06%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)libsystem_m.dylib`exp (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (69 samples, 0.14%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (58 samples, 0.12%)libsystem_m.dylib`exp (6 samples, 0.01%)libsystem_m.dylib`exp (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (52 samples, 0.11%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (51 samples, 0.11%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (43 samples, 0.09%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (20 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (20 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (20 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (20 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (32 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (30 samples, 0.06%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (25 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (25 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (25 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (220 samples, 0.46%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (220 samples, 0.46%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (204 samples, 0.43%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (79 samples, 0.17%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (79 samples, 0.17%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (78 samples, 0.16%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (77 samples, 0.16%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (19 samples, 0.04%)libsystem_kernel.dylib`swtch_pri (5 samples, 0.01%)libsystem_m.dylib`exp (9 samples, 0.02%)libsystem_m.dylib`exp (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (22 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (43 samples, 0.09%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (40 samples, 0.08%)libsystem_m.dylib`exp (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (25 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (25 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (23 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (49 samples, 0.10%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (49 samples, 0.10%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (41 samples, 0.09%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (107 samples, 0.22%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (94 samples, 0.20%)libsystem_m.dylib`exp (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (20 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (22 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (68 samples, 0.14%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (68 samples, 0.14%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (57 samples, 0.12%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (31 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (31 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (30 samples, 0.06%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (215 samples, 0.45%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (210 samples, 0.44%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (33 samples, 0.07%)libsystem_m.dylib`exp (5 samples, 0.01%)libsystem_m.dylib`exp (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (42 samples, 0.09%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (41 samples, 0.09%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (36 samples, 0.08%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (42 samples, 0.09%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (38 samples, 0.08%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (20 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (101 samples, 0.21%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (100 samples, 0.21%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (97 samples, 0.20%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (35 samples, 0.07%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (35 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (34 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (31 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (1,554 samples, 3.26%)sql..sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (1,554 samples, 3.26%)sql..sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (1,525 samples, 3.20%)sql..sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (380 samples, 0.80%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (375 samples, 0.79%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (374 samples, 0.79%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (363 samples, 0.76%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (103 samples, 0.22%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7,610 samples, 15.98%)sqlparser_bench-959bc5267..sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7,579 samples, 15.92%)sqlparser_bench-959bc526..sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (1,568 samples, 3.29%)sql..sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (28 samples, 0.06%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (64 samples, 0.13%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (52 samples, 0.11%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (22 samples, 0.05%)libsystem_m.dylib`exp (45 samples, 0.09%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::median_abs_dev (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`criterion::analysis::estimates::stats (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`criterion::stats::univariate::sample::Sample<A>::percentiles (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (71 samples, 0.15%)libsystem_m.dylib`exp (23 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (32 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (29 samples, 0.06%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (30 samples, 0.06%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (29 samples, 0.06%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (23 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (23 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (67 samples, 0.14%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (67 samples, 0.14%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (29 samples, 0.06%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (28 samples, 0.06%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (52 samples, 0.11%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (52 samples, 0.11%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (49 samples, 0.10%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (133 samples, 0.28%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (132 samples, 0.28%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (25 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (25 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (25 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (193 samples, 0.41%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (193 samples, 0.41%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (193 samples, 0.41%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (192 samples, 0.40%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (34 samples, 0.07%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (34 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (34 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (33 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (298 samples, 0.63%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (298 samples, 0.63%)libsystem_m.dylib`exp (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (38 samples, 0.08%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (38 samples, 0.08%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (38 samples, 0.08%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon::iter::fold::FoldFolder<C,ID,F> as rayon::iter::plumbing::Folder<T>>::consume_iter (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (26 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (25 samples, 0.05%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (59 samples, 0.12%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (57 samples, 0.12%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (16 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (10 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (20 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (116 samples, 0.24%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (116 samples, 0.24%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (116 samples, 0.24%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (116 samples, 0.24%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (40 samples, 0.08%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (40 samples, 0.08%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (40 samples, 0.08%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (39 samples, 0.08%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (453 samples, 0.95%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (453 samples, 0.95%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (21 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (19 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::job::StackJob<L,F,R>::run_inline (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (509 samples, 1.07%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (509 samples, 1.07%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (35 samples, 0.07%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (35 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (34 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (33 samples, 0.07%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (514 samples, 1.08%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (514 samples, 1.08%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (514 samples, 1.08%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (514 samples, 1.08%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::iter::plumbing::bridge_producer_consumer::helper (517 samples, 1.09%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (515 samples, 1.08%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`<rayon_core::job::StackJob<L,F,R> as rayon_core::job::Job>::execute (8,206 samples, 17.23%)sqlparser_bench-959bc526797..sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (525 samples, 1.10%)sqlparser_bench-959bc5267970ca34`rayon::slice::quicksort::recurse (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`rayon_core::join::join_context::_{{closure}} (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<core::iter::adapters::chain::Chain<A,B> as core::iter::traits::iterator::Iterator>::try_fold (13 samples, 0.03%)sqlparser_bench-959bc5267970ca34`crossbeam_deque::deque::Stealer<T>::steal (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`crossbeam_epoch::default::with_handle (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::find_work (14 samples, 0.03%)libsystem_kernel.dylib`__psynch_cvwait (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`rayon_core::sleep::Sleep::sleep (8 samples, 0.02%)libsystem_pthread.dylib`_pthread_mutex_firstfit_lock_slow (10 samples, 0.02%)libsystem_kernel.dylib`__psynch_mutexwait (10 samples, 0.02%)libsystem_pthread.dylib`thread_start (8,379 samples, 17.60%)libsystem_pthread.dylib`thr..libsystem_pthread.dylib`_pthread_start (8,379 samples, 17.60%)libsystem_pthread.dylib`_pt..sqlparser_bench-959bc5267970ca34`std::sys::pal::unix::thread::Thread::new::thread_start (8,379 samples, 17.60%)sqlparser_bench-959bc526797..sqlparser_bench-959bc5267970ca34`core::ops::function::FnOnce::call_once{{vtable.shim}} (8,379 samples, 17.60%)sqlparser_bench-959bc526797..sqlparser_bench-959bc5267970ca34`std::sys::backtrace::__rust_begin_short_backtrace (8,379 samples, 17.60%)sqlparser_bench-959bc526797..sqlparser_bench-959bc5267970ca34`rayon_core::registry::ThreadBuilder::run (8,379 samples, 17.60%)sqlparser_bench-959bc526797..sqlparser_bench-959bc5267970ca34`rayon_core::registry::WorkerThread::wait_until_cold (8,379 samples, 17.60%)sqlparser_bench-959bc526797..sqlparser_bench-959bc5267970ca34`rayon_core::sleep::Sleep::wake_any_threads (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`rayon_core::sleep::Sleep::wake_specific_thread (17 samples, 0.04%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::RawVecInner<A>::reserve::do_reserve_and_handle (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`alloc::raw_vec::finish_grow (12 samples, 0.03%)libsystem_malloc.dylib`_realloc (12 samples, 0.03%)libsystem_malloc.dylib`_malloc_zone_realloc (12 samples, 0.03%)libsystem_platform.dylib`_platform_memmove (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<&T as core::fmt::Display>::fmt (72 samples, 0.15%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (133 samples, 0.28%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt (37 samples, 0.08%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (96 samples, 0.20%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Ident as core::fmt::Display>::fmt (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::operator::BinaryOperator as core::fmt::Display>::fmt (58 samples, 0.12%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::value::Value as core::fmt::Display>::fmt (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::write_str (12 samples, 0.03%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,141 samples, 2.40%)sq..sqlparser_bench-959bc5267970ca34`core::fmt::write (713 samples, 1.50%)libdyld.dylib`tlv_get_addr (127 samples, 0.27%)sqlparser_bench-959bc5267970ca34`psm::stack_pointer (44 samples, 0.09%)sqlparser_bench-959bc5267970ca34`rust_psm_stack_pointer (124 samples, 0.26%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt (408 samples, 0.86%)sqlparser_bench-959bc5267970ca34`stacker::remaining_stack (113 samples, 0.24%)sqlparser_bench-959bc5267970ca34`<&T as core::fmt::Display>::fmt (27 samples, 0.06%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (68 samples, 0.14%)sqlparser_bench-959bc5267970ca34`<str as core::fmt::Display>::fmt (20 samples, 0.04%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::pad (65 samples, 0.14%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,858 samples, 3.90%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,846 samples, 3.88%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,846 samples, 3.88%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,846 samples, 3.88%)sqlp..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,846 samples, 3.88%)sqlp..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::value::Value as core::fmt::Display>::fmt (297 samples, 0.62%)sqlparser_bench-959bc5267970ca34`core::fmt::write (117 samples, 0.25%)libsystem_platform.dylib`_platform_memmove (253 samples, 0.53%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (108 samples, 0.23%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt (62 samples, 0.13%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (372 samples, 0.78%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Ident as core::fmt::Display>::fmt (45 samples, 0.09%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::value::Value as core::fmt::Display>::fmt (57 samples, 0.12%)sqlparser_bench-959bc5267970ca34`DYLD-STUB$$memcpy (71 samples, 0.15%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::write_fmt (32 samples, 0.07%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::write_str (34 samples, 0.07%)sqlparser_bench-959bc5267970ca34`core::fmt::write (127 samples, 0.27%)sqlparser_bench-959bc5267970ca34`recursive::get_minimum_stack_size (101 samples, 0.21%)sqlparser_bench-959bc5267970ca34`recursive::get_stack_allocation_size (63 samples, 0.13%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,396 samples, 2.93%)sq..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,396 samples, 2.93%)sq..sqlparser_bench-959bc5267970ca34`stacker::remaining_stack (71 samples, 0.15%)libsystem_platform.dylib`_platform_memmove (84 samples, 0.18%)sqlparser_bench-959bc5267970ca34`<alloc::string::String as core::fmt::Write>::write_str (47 samples, 0.10%)sqlparser_bench-959bc5267970ca34`<str as core::fmt::Display>::fmt (25 samples, 0.05%)sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,590 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::Expr as core::fmt::Display>::fmt::_{{closure}} (1,589 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`core::fmt::write (1,589 samples, 3.34%)sql..sqlparser_bench-959bc5267970ca34`<sqlparser::ast::value::Value as core::fmt::Display>::fmt (193 samples, 0.41%)sqlparser_bench-959bc5267970ca34`core::fmt::write (193 samples, 0.41%)sqlparser_bench-959bc5267970ca34`core::fmt::Formatter::pad (36 samples, 0.08%)sqlparser_bench-959bc5267970ca34`core::fmt::write (1,598 samples, 3.36%)sql..libsystem_malloc.dylib`free_tiny (6 samples, 0.01%)libsystem_malloc.dylib`tiny_free_no_lock (6 samples, 0.01%)libsystem_malloc.dylib`tiny_free_list_add_ptr (7 samples, 0.01%)libsystem_malloc.dylib`tiny_free_scan_madvise_free (6 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (29 samples, 0.06%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (20 samples, 0.04%)libsystem_malloc.dylib`free_tiny (20 samples, 0.04%)libsystem_malloc.dylib`tiny_free_no_lock (20 samples, 0.04%)libsystem_malloc.dylib`tiny_free_scan_madvise_free (5 samples, 0.01%)libsystem_kernel.dylib`madvise (5 samples, 0.01%)libsystem_malloc.dylib`free_tiny (9 samples, 0.02%)libsystem_malloc.dylib`tiny_free_no_lock (9 samples, 0.02%)libsystem_malloc.dylib`tiny_free_list_add_ptr (8 samples, 0.02%)libsystem_malloc.dylib`tiny_free_list_remove_ptr (7 samples, 0.01%)libsystem_malloc.dylib`free_tiny (20 samples, 0.04%)libsystem_malloc.dylib`tiny_free_no_lock (20 samples, 0.04%)libsystem_malloc.dylib`free_tiny (11 samples, 0.02%)libsystem_malloc.dylib`tiny_free_no_lock (9 samples, 0.02%)libsystem_malloc.dylib`_nanov2_free (7 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (10 samples, 0.02%)libsystem_malloc.dylib`_nanov2_free (5 samples, 0.01%)libsystem_malloc.dylib`free_tiny (11 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (54 samples, 0.11%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (33 samples, 0.07%)libsystem_malloc.dylib`free_tiny (16 samples, 0.03%)libsystem_malloc.dylib`tiny_free_no_lock (12 samples, 0.03%)libsystem_malloc.dylib`_free (7 samples, 0.01%)libsystem_malloc.dylib`_szone_free (8 samples, 0.02%)libsystem_malloc.dylib`free_tiny (13 samples, 0.03%)libsystem_platform.dylib`_platform_memset (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (94 samples, 0.20%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (267 samples, 0.56%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (238 samples, 0.50%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (229 samples, 0.48%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (155 samples, 0.33%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (139 samples, 0.29%)libsystem_malloc.dylib`tiny_free_scan_madvise_free (11 samples, 0.02%)libsystem_kernel.dylib`madvise (11 samples, 0.02%)libsystem_malloc.dylib`free_tiny (15 samples, 0.03%)libsystem_malloc.dylib`tiny_free_no_lock (15 samples, 0.03%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (18 samples, 0.04%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (18 samples, 0.04%)libsystem_kernel.dylib`madvise (5 samples, 0.01%)libsystem_malloc.dylib`free_tiny (8 samples, 0.02%)libsystem_malloc.dylib`tiny_free_no_lock (8 samples, 0.02%)libsystem_malloc.dylib`tiny_madvise_free_range_no_lock (6 samples, 0.01%)libsystem_malloc.dylib`tiny_free_list_remove_ptr (6 samples, 0.01%)libsystem_malloc.dylib`free_tiny (12 samples, 0.03%)libsystem_malloc.dylib`tiny_free_no_lock (12 samples, 0.03%)libsystem_malloc.dylib`free_tiny (11 samples, 0.02%)libsystem_malloc.dylib`tiny_free_no_lock (9 samples, 0.02%)libsystem_malloc.dylib`_nanov2_free (8 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (37 samples, 0.08%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (25 samples, 0.05%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (14 samples, 0.03%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (6 samples, 0.01%)libsystem_malloc.dylib`free_tiny (16 samples, 0.03%)libsystem_malloc.dylib`tiny_free_no_lock (16 samples, 0.03%)libsystem_malloc.dylib`tiny_free_no_lock (12 samples, 0.03%)libsystem_malloc.dylib`free_tiny (16 samples, 0.03%)libsystem_malloc.dylib`_free (7 samples, 0.01%)libsystem_malloc.dylib`_szone_free (5 samples, 0.01%)libsystem_malloc.dylib`free_tiny (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (36 samples, 0.08%)libsystem_malloc.dylib`free_tiny (5 samples, 0.01%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (9 samples, 0.02%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (165 samples, 0.35%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (147 samples, 0.31%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (147 samples, 0.31%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (102 samples, 0.21%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<alloc::boxed::Box<sqlparser::ast::Expr>> (86 samples, 0.18%)sqlparser_bench-959bc5267970ca34`core::ptr::drop_in_place<sqlparser::ast::Expr> (34 samples, 0.07%)all (47,617 samples, 100%)apache-datafusion-sqlparser-rs-0.62.0/src/000077500000000000000000000000001517524037000204025ustar00rootroot00000000000000apache-datafusion-sqlparser-rs-0.62.0/src/ast/000077500000000000000000000000001517524037000211715ustar00rootroot00000000000000apache-datafusion-sqlparser-rs-0.62.0/src/ast/comments.rs000066400000000000000000000262261517524037000233740ustar00rootroot00000000000000// Licensed 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. //! Provides a representation of source code comments in parsed SQL code. //! //! See [Comments::find] for an example. #[cfg(not(feature = "std"))] use alloc::{string::String, vec::Vec}; use core::{ ops::{Bound, Deref, RangeBounds}, slice, }; use crate::tokenizer::{Location, Span}; /// An opaque container for comments from a parse SQL source code. #[derive(Default, Debug, Clone)] pub struct Comments(Vec); impl Comments { /// Accepts `comment` if its the first or is located strictly after the /// last accepted comment. In other words, this method will skip the /// comment if its comming out of order (as encountered in the parsed /// source code.) pub(crate) fn offer(&mut self, comment: CommentWithSpan) { if self .0 .last() .map(|last| last.span < comment.span) .unwrap_or(true) { self.0.push(comment); } } /// Finds comments starting within the given location range. The order of /// iterator reflects the order of the comments as encountered in the parsed /// source code. /// /// # Example /// ```rust /// use sqlparser::{dialect::GenericDialect, parser::Parser, tokenizer::Location}; /// /// let sql = r#"/* /// header comment ... /// ... spanning multiple lines /// */ /// /// -- first statement /// SELECT 'hello' /* world */ FROM DUAL; /// /// -- second statement /// SELECT 123 FROM DUAL; /// /// -- trailing comment /// "#; /// /// let (ast, comments) = Parser::parse_sql_with_comments(&GenericDialect, sql).unwrap(); /// /// // all comments appearing before line seven, i.e. before the first statement itself /// assert_eq!( /// &comments.find(..Location::new(7, 1)).map(|c| c.as_str()).collect::>(), /// &["\n header comment ...\n ... spanning multiple lines\n", " first statement\n"]); /// /// // all comments appearing within the first statement /// assert_eq!( /// &comments.find(Location::new(7, 1)..Location::new(8,1)).map(|c| c.as_str()).collect::>(), /// &[" world "]); /// /// // all comments appearing within or after the first statement /// assert_eq!( /// &comments.find(Location::new(7, 1)..).map(|c| c.as_str()).collect::>(), /// &[" world ", " second statement\n", " trailing comment\n"]); /// ``` /// /// The [Spanned](crate::ast::Spanned) trait allows you to access location /// information for certain AST nodes. pub fn find>(&self, range: R) -> Iter<'_> { let (start, end) = ( self.start_index(range.start_bound()), self.end_index(range.end_bound()), ); debug_assert!((0..=self.0.len()).contains(&start)); debug_assert!((0..=self.0.len()).contains(&end)); // in case the user specified a reverse range Iter(if start <= end { self.0[start..end].iter() } else { self.0[0..0].iter() }) } /// Find the index of the first comment starting "before" the given location. /// /// The returned index is _inclusive_ and within the range of `0..=self.0.len()`. fn start_index(&self, location: Bound<&Location>) -> usize { match location { Bound::Included(location) => { match self.0.binary_search_by(|c| c.span.start.cmp(location)) { Ok(i) => i, Err(i) => i, } } Bound::Excluded(location) => { match self.0.binary_search_by(|c| c.span.start.cmp(location)) { Ok(i) => i + 1, Err(i) => i, } } Bound::Unbounded => 0, } } /// Find the index of the first comment starting "after" the given location. /// /// The returned index is _exclusive_ and within the range of `0..=self.0.len()`. fn end_index(&self, location: Bound<&Location>) -> usize { match location { Bound::Included(location) => { match self.0.binary_search_by(|c| c.span.start.cmp(location)) { Ok(i) => i + 1, Err(i) => i, } } Bound::Excluded(location) => { match self.0.binary_search_by(|c| c.span.start.cmp(location)) { Ok(i) => i, Err(i) => i, } } Bound::Unbounded => self.0.len(), } } } impl From for Vec { fn from(comments: Comments) -> Self { comments.0 } } /// A source code comment with information of its entire span. #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct CommentWithSpan { /// The source code comment iself pub comment: Comment, /// The span of the comment including its markers pub span: Span, } impl Deref for CommentWithSpan { type Target = Comment; fn deref(&self) -> &Self::Target { &self.comment } } /// A unified type of the different source code comment formats. #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub enum Comment { /// A single line comment, typically introduced with a prefix and spanning /// until end-of-line or end-of-file in the source code. /// /// Note: `content` will include the terminating new-line character, if any. /// A single-line comment, typically introduced with a prefix and spanning /// until end-of-line or end-of-file in the source code. /// /// Note: `content` will include the terminating new-line character, if any. SingleLine { /// The content of the comment (including trailing newline, if any). content: String, /// The prefix introducing the comment (e.g. `--`, `#`). prefix: String, }, /// A multi-line comment, typically enclosed in `/* .. */` markers. The /// string represents the content excluding the markers. MultiLine(String), } impl Comment { /// Retrieves the content of the comment as string slice. pub fn as_str(&self) -> &str { match self { Comment::SingleLine { content, prefix: _ } => content.as_str(), Comment::MultiLine(content) => content.as_str(), } } } impl Deref for Comment { type Target = str; fn deref(&self) -> &Self::Target { self.as_str() } } /// An opaque iterator implementation over comments served by [Comments::find]. pub struct Iter<'a>(slice::Iter<'a, CommentWithSpan>); impl<'a> Iterator for Iter<'a> { type Item = &'a CommentWithSpan; fn next(&mut self) -> Option { self.0.next() } } #[cfg(test)] mod tests { use super::*; #[test] fn test_find() { let comments = { // ``` // -- abc // /* hello */--, world // /* def // ghi // jkl // */ // ``` let mut c = Comments(Vec::new()); c.offer(CommentWithSpan { comment: Comment::SingleLine { content: " abc".into(), prefix: "--".into(), }, span: Span::new((1, 1).into(), (1, 7).into()), }); c.offer(CommentWithSpan { comment: Comment::MultiLine(" hello ".into()), span: Span::new((2, 3).into(), (2, 14).into()), }); c.offer(CommentWithSpan { comment: Comment::SingleLine { content: ", world".into(), prefix: "--".into(), }, span: Span::new((2, 14).into(), (2, 21).into()), }); c.offer(CommentWithSpan { comment: Comment::MultiLine(" def\n ghi\n jkl\n".into()), span: Span::new((3, 3).into(), (7, 1).into()), }); c }; fn find>(comments: &Comments, range: R) -> Vec<&str> { comments.find(range).map(|c| c.as_str()).collect::>() } // ~ end-points only -------------------------------------------------- assert_eq!(find(&comments, ..Location::new(0, 0)), Vec::<&str>::new()); assert_eq!(find(&comments, ..Location::new(2, 1)), vec![" abc"]); assert_eq!(find(&comments, ..Location::new(2, 3)), vec![" abc"]); assert_eq!( find(&comments, ..=Location::new(2, 3)), vec![" abc", " hello "] ); assert_eq!( find(&comments, ..=Location::new(2, 3)), vec![" abc", " hello "] ); assert_eq!( find(&comments, ..Location::new(2, 15)), vec![" abc", " hello ", ", world"] ); // ~ start-points only ------------------------------------------------ assert_eq!( find(&comments, Location::new(1000, 1000)..), Vec::<&str>::new() ); assert_eq!( find(&comments, Location::new(2, 14)..), vec![", world", " def\n ghi\n jkl\n"] ); assert_eq!( find(&comments, Location::new(2, 15)..), vec![" def\n ghi\n jkl\n"] ); assert_eq!( find(&comments, Location::new(0, 0)..), vec![" abc", " hello ", ", world", " def\n ghi\n jkl\n"] ); assert_eq!( find(&comments, Location::new(1, 1)..), vec![" abc", " hello ", ", world", " def\n ghi\n jkl\n"] ); // ~ ranges ----------------------------------------------------------- assert_eq!( find(&comments, Location::new(2, 1)..Location::new(1, 1)), Vec::<&str>::new() ); assert_eq!( find(&comments, Location::new(1, 1)..Location::new(2, 3)), vec![" abc"] ); assert_eq!( find(&comments, Location::new(1, 1)..=Location::new(2, 3)), vec![" abc", " hello "] ); assert_eq!( find(&comments, Location::new(1, 1)..=Location::new(2, 10)), vec![" abc", " hello "] ); assert_eq!( find(&comments, Location::new(1, 1)..=Location::new(2, 14)), vec![" abc", " hello ", ", world"] ); assert_eq!( find(&comments, Location::new(1, 1)..Location::new(2, 15)), vec![" abc", " hello ", ", world"] ); // ~ find everything -------------------------------------------------- assert_eq!( find(&comments, ..), vec![" abc", " hello ", ", world", " def\n ghi\n jkl\n"] ); } } apache-datafusion-sqlparser-rs-0.62.0/src/ast/data_type.rs000066400000000000000000001377041517524037000235250ustar00rootroot00000000000000// 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. #[cfg(not(feature = "std"))] use alloc::{boxed::Box, format, string::String, vec::Vec}; use core::fmt; #[cfg(feature = "serde")] use serde::{Deserialize, Serialize}; #[cfg(feature = "visitor")] use sqlparser_derive::{Visit, VisitMut}; use crate::ast::{display_comma_separated, Expr, 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))] /// A member of an ENUM type. pub enum EnumMember { /// Just a name. 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>), /// 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, }, /// Fixed-length character type, e.g. CHARACTER(10). Character(Option), /// Fixed-length char type, e.g. CHAR(10). Char(Option), /// Character varying type, e.g. CHARACTER VARYING(10). CharacterVarying(Option), /// Char varying type, e.g. CHAR VARYING(10). CharVarying(Option), /// Variable-length character type, e.g. VARCHAR(10). Varchar(Option), /// Variable-length character type, e.g. NVARCHAR(10). Nvarchar(Option), /// Uuid type. Uuid, /// Large character object with optional length, /// e.g. CHARACTER LARGE OBJECT, CHARACTER LARGE OBJECT(1000), [SQL Standard]. /// /// [SQL Standard]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#character-large-object-type CharacterLargeObject(Option), /// Large character object with optional length, /// e.g. CHAR LARGE OBJECT, CHAR LARGE OBJECT(1000), [SQL Standard]. /// /// [SQL Standard]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#character-large-object-type CharLargeObject(Option), /// Large character object with optional length, /// e.g. CLOB, CLOB(1000), [SQL Standard]. /// /// [SQL Standard]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#character-large-object-type /// [Oracle]: https://docs.oracle.com/javadb/10.10.1.2/ref/rrefclob.html Clob(Option), /// Fixed-length binary type with optional length, /// see [SQL Standard], [MS SQL Server]. /// /// [SQL Standard]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#binary-string-type /// [MS SQL Server]: https://learn.microsoft.com/pt-br/sql/t-sql/data-types/binary-and-varbinary-transact-sql?view=sql-server-ver16 Binary(Option), /// Variable-length binary with optional length type, /// see [SQL Standard], [MS SQL Server]. /// /// [SQL Standard]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#binary-string-type /// [MS SQL Server]: https://learn.microsoft.com/pt-br/sql/t-sql/data-types/binary-and-varbinary-transact-sql?view=sql-server-ver16 Varbinary(Option), /// Large binary object with optional length, /// see [SQL Standard], [Oracle]. /// /// [SQL Standard]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#binary-large-object-string-type /// [Oracle]: https://docs.oracle.com/javadb/10.8.3.0/ref/rrefblob.html Blob(Option), /// [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 Bytes(Option), /// Numeric type with optional precision and scale, e.g. NUMERIC(10,2), [SQL Standard][1]. /// /// [1]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#exact-numeric-type Numeric(ExactNumberInfo), /// Decimal type with optional precision and scale, e.g. DECIMAL(10,2), [SQL Standard][1]. /// /// [1]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#exact-numeric-type Decimal(ExactNumberInfo), /// [MySQL] unsigned decimal with optional precision and scale, e.g. DECIMAL UNSIGNED or DECIMAL(10,2) UNSIGNED. /// Note: Using UNSIGNED with DECIMAL is deprecated in recent versions of MySQL. /// /// [MySQL]: https://dev.mysql.com/doc/refman/8.4/en/numeric-type-syntax.html DecimalUnsigned(ExactNumberInfo), /// [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. /// /// [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]. /// /// [1]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#exact-numeric-type Dec(ExactNumberInfo), /// [MySQL] unsigned decimal (DEC alias) with optional precision and scale, e.g. DEC UNSIGNED or DEC(10,2) UNSIGNED. /// Note: Using UNSIGNED with DEC is deprecated in recent versions of MySQL. /// /// [MySQL]: https://dev.mysql.com/doc/refman/8.4/en/numeric-type-syntax.html DecUnsigned(ExactNumberInfo), /// Floating point with optional precision and scale, e.g. FLOAT, FLOAT(8), or FLOAT(8,2). Float(ExactNumberInfo), /// [MySQL] unsigned floating point with optional precision and scale, e.g. /// FLOAT UNSIGNED, FLOAT(10) UNSIGNED or FLOAT(10,2) UNSIGNED. /// Note: Using UNSIGNED with FLOAT is deprecated in recent versions of MySQL. /// /// [MySQL]: https://dev.mysql.com/doc/refman/8.4/en/numeric-type-syntax.html FloatUnsigned(ExactNumberInfo), /// Tiny integer with optional display width, e.g. TINYINT or TINYINT(3). TinyInt(Option), /// Unsigned tiny integer with optional display width, /// e.g. TINYINT UNSIGNED or TINYINT(3) UNSIGNED. TinyIntUnsigned(Option), /// Unsigned tiny integer, e.g. UTINYINT UTinyInt, /// Int2 is an alias for SmallInt in [PostgreSQL]. /// Note: Int2 means 2 bytes in PostgreSQL (not 2 bits). /// Int2 with optional display width, e.g. INT2 or INT2(5). /// /// [PostgreSQL]: https://www.postgresql.org/docs/current/datatype.html Int2(Option), /// Unsigned Int2 with optional display width, e.g. INT2 UNSIGNED or INT2(5) UNSIGNED. Int2Unsigned(Option), /// Small integer with optional display width, e.g. SMALLINT or SMALLINT(5). SmallInt(Option), /// Unsigned small integer with optional display width, /// e.g. SMALLINT UNSIGNED or SMALLINT(5) UNSIGNED. SmallIntUnsigned(Option), /// Unsigned small integer, e.g. USMALLINT. USmallInt, /// MySQL medium integer ([1]) with optional display width, /// e.g. MEDIUMINT or MEDIUMINT(5). /// /// [1]: https://dev.mysql.com/doc/refman/8.0/en/integer-types.html MediumInt(Option), /// 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), /// Int with optional display width, e.g. INT or INT(11). Int(Option), /// Int4 is an alias for Integer in [PostgreSQL]. /// Note: Int4 means 4 bytes in PostgreSQL (not 4 bits). /// Int4 with optional display width, e.g. Int4 or Int4(11). /// /// [PostgreSQL]: https://www.postgresql.org/docs/current/datatype.html Int4(Option), /// Int8 is an alias for BigInt in [PostgreSQL] and Integer type in [ClickHouse]. /// Int8 with optional display width, e.g. INT8 or INT8(11). /// Note: Int8 means 8 bytes in [PostgreSQL], but 8 bits in [ClickHouse]. /// /// [PostgreSQL]: https://www.postgresql.org/docs/current/datatype.html /// [ClickHouse]: https://clickhouse.com/docs/en/sql-reference/data-types/int-uint Int8(Option), /// Integer type in [ClickHouse]. /// Note: Int16 means 16 bits in [ClickHouse]. /// /// [ClickHouse]: https://clickhouse.com/docs/en/sql-reference/data-types/int-uint Int16, /// Integer type in [ClickHouse]. /// Note: Int32 means 32 bits in [ClickHouse]. /// /// [ClickHouse]: https://clickhouse.com/docs/en/sql-reference/data-types/int-uint Int32, /// 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 Int64, /// Integer type in [ClickHouse]. /// Note: Int128 means 128 bits in [ClickHouse]. /// /// [ClickHouse]: https://clickhouse.com/docs/en/sql-reference/data-types/int-uint Int128, /// Integer type in [ClickHouse]. /// Note: Int256 means 256 bits in [ClickHouse]. /// /// [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(Option), /// Unsigned int with optional display width, e.g. INT UNSIGNED or INT(11) UNSIGNED. IntUnsigned(Option), /// Unsigned int4 with optional display width, e.g. INT4 UNSIGNED or INT4(11) UNSIGNED. Int4Unsigned(Option), /// Unsigned integer with optional display width, e.g. INTEGER UNSIGNED or INTEGER(11) UNSIGNED. IntegerUnsigned(Option), /// 128-bit integer type, e.g. HUGEINT. HugeInt, /// Unsigned 128-bit integer type, e.g. UHUGEINT. UHugeInt, /// Unsigned integer type in [ClickHouse]. /// Note: UInt8 means 8 bits in [ClickHouse]. /// /// [ClickHouse]: https://clickhouse.com/docs/en/sql-reference/data-types/int-uint UInt8, /// Unsigned integer type in [ClickHouse]. /// Note: UInt16 means 16 bits in [ClickHouse]. /// /// [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]. /// /// [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]. /// /// [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]. /// /// [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]. /// /// [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). BigInt(Option), /// Unsigned big integer with optional display width, e.g. BIGINT UNSIGNED or BIGINT(20) UNSIGNED. BigIntUnsigned(Option), /// Unsigned big integer, e.g. UBIGINT. UBigInt, /// Unsigned Int8 with optional display width, e.g. INT8 UNSIGNED or INT8(11) UNSIGNED. Int8Unsigned(Option), /// 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 Signed, /// Signed integer as used in [MySQL CAST] target types, with optional `INTEGER` suffix, /// e.g. `SIGNED INTEGER` /// /// [MySQL CAST]: https://dev.mysql.com/doc/refman/8.4/en/cast-functions.html SignedInteger, /// Signed integer as used in [MySQL CAST] target types, without optional `INTEGER` suffix, /// e.g. `SIGNED` /// /// [MySQL CAST]: https://dev.mysql.com/doc/refman/8.4/en/cast-functions.html Unsigned, /// Unsigned integer as used in [MySQL CAST] target types, with optional `INTEGER` suffix, /// e.g. `UNSIGNED INTEGER`. /// /// [MySQL CAST]: https://dev.mysql.com/doc/refman/8.4/en/cast-functions.html UnsignedInteger, /// Float4 is an alias for Real in [PostgreSQL]. /// /// [PostgreSQL]: https://www.postgresql.org/docs/current/datatype.html Float4, /// Floating point in [ClickHouse]. /// /// [ClickHouse]: https://clickhouse.com/docs/en/sql-reference/data-types/float Float32, /// 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 Float64, /// Floating point, e.g. REAL. Real, /// [MySQL] unsigned real, e.g. REAL UNSIGNED. /// Note: Using UNSIGNED with REAL is deprecated in recent versions of MySQL. /// /// [MySQL]: https://dev.mysql.com/doc/refman/8.4/en/numeric-type-syntax.html RealUnsigned, /// Float8 is an alias for Double in [PostgreSQL]. /// /// [PostgreSQL]: https://www.postgresql.org/docs/current/datatype.html Float8, /// Double Double(ExactNumberInfo), /// [MySQL] unsigned double precision with optional precision, e.g. DOUBLE UNSIGNED or DOUBLE(10,2) UNSIGNED. /// Note: Using UNSIGNED with DOUBLE is deprecated in recent versions of MySQL. /// /// [MySQL]: https://dev.mysql.com/doc/refman/8.4/en/numeric-type-syntax.html DoubleUnsigned(ExactNumberInfo), /// Double Precision, see [SQL 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 DoublePrecision, /// [MySQL] unsigned double precision, e.g. DOUBLE PRECISION UNSIGNED. /// Note: Using UNSIGNED with DOUBLE PRECISION is deprecated in recent versions of MySQL. /// /// [MySQL]: https://dev.mysql.com/doc/refman/8.4/en/numeric-type-syntax.html DoublePrecisionUnsigned, /// Bool is an alias for Boolean, see [PostgreSQL]. /// /// [PostgreSQL]: https://www.postgresql.org/docs/current/datatype.html Bool, /// Boolean type. Boolean, /// Date type. Date, /// 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]. /// /// [1]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#datetime-type Time(Option, TimezoneInfo), /// Datetime with optional time precision, see [MySQL][1]. /// /// [1]: https://dev.mysql.com/doc/refman/8.0/en/datetime.html Datetime(Option), /// Datetime with time precision and optional timezone, see [ClickHouse][1]. /// /// [1]: https://clickhouse.com/docs/en/sql-reference/data-types/datetime64 Datetime64(u64, Option), /// Timestamp with optional time precision and time zone information, see [SQL Standard][1]. /// /// [1]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#datetime-type Timestamp(Option, TimezoneInfo), /// Databricks timestamp without time zone. See [1]. /// /// [1]: https://docs.databricks.com/aws/en/sql/language-manual/data-types/timestamp-ntz-type TimestampNtz(Option), /// Interval type. Interval { /// [PostgreSQL] fields specification like `INTERVAL YEAR TO MONTH`. /// /// [PostgreSQL]: https://www.postgresql.org/docs/17/datatype-datetime.html fields: Option, /// [PostgreSQL] subsecond precision like `INTERVAL HOUR TO SECOND(3)` /// /// [PostgreSQL]: https://www.postgresql.org/docs/17/datatype-datetime.html precision: Option, }, /// JSON type. JSON, /// Binary JSON type. JSONB, /// Regclass used in [PostgreSQL] serial. /// /// [PostgreSQL]: https://www.postgresql.org/docs/current/datatype.html Regclass, /// Text type. 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), /// 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, /// 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), /// `BIT VARYING(n)`: Variable-length bit string, see [PostgreSQL]. /// /// [PostgreSQL]: https://www.postgresql.org/docs/current/datatype-bit.html BitVarying(Option), /// `VARBIT(n)`: Variable-length bit string. [PostgreSQL] alias for `BIT VARYING`. /// /// [PostgreSQL]: https://www.postgresql.org/docs/current/datatype.html VarBit(Option), /// Custom types. Custom(ObjectName, Vec), /// Arrays. Array(ArrayElemTypeDef), /// Map, see [ClickHouse]. /// /// [ClickHouse]: https://clickhouse.com/docs/en/sql-reference/data-types/map Map(Box, Box), /// Tuple, see [ClickHouse]. /// /// [ClickHouse]: https://clickhouse.com/docs/en/sql-reference/data-types/tuple Tuple(Vec), /// Nested type, see [ClickHouse]. /// /// [ClickHouse]: https://clickhouse.com/docs/en/sql-reference/data-types/nested-data-structures/nested Nested(Vec), /// Enum type. Enum(Vec, Option), /// Set type. Set(Vec), /// Struct type, see [Hive], [BigQuery]. /// /// [Hive]: https://docs.cloudera.com/cdw-runtime/cloud/impala-sql-reference/topics/impala-struct.html /// [BigQuery]: https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types#struct_type Struct(Vec, StructBracketKind), /// Union type, see [DuckDB]. /// /// [DuckDB]: https://duckdb.org/docs/sql/data_types/union.html Union(Vec), /// Nullable - special marker NULL represents in ClickHouse as a data type. /// /// [ClickHouse]: https://clickhouse.com/docs/en/sql-reference/data-types/nullable Nullable(Box), /// LowCardinality - changes the internal representation of other data types to be dictionary-encoded. /// /// [ClickHouse]: https://clickhouse.com/docs/en/sql-reference/data-types/lowcardinality LowCardinality(Box), /// 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]. /// /// [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 { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { DataType::Character(size) => format_character_string_type(f, "CHARACTER", size), DataType::Char(size) => format_character_string_type(f, "CHAR", size), 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), DataType::Uuid => write!(f, "UUID"), DataType::CharacterLargeObject(size) => { format_type_with_optional_length(f, "CHARACTER LARGE OBJECT", size, false) } DataType::CharLargeObject(size) => { format_type_with_optional_length(f, "CHAR LARGE OBJECT", size, false) } 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::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}") } DataType::Decimal(info) => { write!(f, "DECIMAL{info}") } DataType::DecimalUnsigned(info) => { write!(f, "DECIMAL{info} UNSIGNED") } DataType::Dec(info) => { write!(f, "DEC{info}") } DataType::DecUnsigned(info) => { write!(f, "DEC{info} UNSIGNED") } DataType::BigNumeric(info) => write!(f, "BIGNUMERIC{info}"), DataType::BigDecimal(info) => write!(f, "BIGDECIMAL{info}"), DataType::Float(info) => write!(f, "FLOAT{info}"), DataType::FloatUnsigned(info) => write!(f, "FLOAT{info} UNSIGNED"), DataType::TinyInt(zerofill) => { format_type_with_optional_length(f, "TINYINT", zerofill, false) } DataType::TinyIntUnsigned(zerofill) => { format_type_with_optional_length(f, "TINYINT", zerofill, true) } DataType::Int2(zerofill) => { format_type_with_optional_length(f, "INT2", zerofill, false) } DataType::Int2Unsigned(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) => { format_type_with_optional_length(f, "SMALLINT", zerofill, true) } DataType::MediumInt(zerofill) => { format_type_with_optional_length(f, "MEDIUMINT", zerofill, false) } DataType::MediumIntUnsigned(zerofill) => { format_type_with_optional_length(f, "MEDIUMINT", zerofill, true) } DataType::Int(zerofill) => format_type_with_optional_length(f, "INT", zerofill, false), DataType::IntUnsigned(zerofill) => { format_type_with_optional_length(f, "INT", zerofill, true) } DataType::Int4(zerofill) => { format_type_with_optional_length(f, "INT4", zerofill, false) } DataType::Int8(zerofill) => { format_type_with_optional_length(f, "INT8", zerofill, false) } DataType::Int16 => { write!(f, "Int16") } DataType::Int32 => { write!(f, "Int32") } DataType::Int64 => { write!(f, "INT64") } DataType::Int128 => { write!(f, "Int128") } DataType::Int256 => { write!(f, "Int256") } DataType::HugeInt => { write!(f, "HUGEINT") } DataType::Int4Unsigned(zerofill) => { format_type_with_optional_length(f, "INT4", zerofill, true) } DataType::Integer(zerofill) => { format_type_with_optional_length(f, "INTEGER", zerofill, false) } DataType::IntegerUnsigned(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) => { format_type_with_optional_length(f, "BIGINT", zerofill, true) } DataType::Int8Unsigned(zerofill) => { format_type_with_optional_length(f, "INT8", zerofill, true) } DataType::UTinyInt => { write!(f, "UTINYINT") } DataType::USmallInt => { write!(f, "USMALLINT") } DataType::UBigInt => { write!(f, "UBIGINT") } DataType::UHugeInt => { write!(f, "UHUGEINT") } DataType::UInt8 => { write!(f, "UInt8") } DataType::UInt16 => { write!(f, "UInt16") } DataType::UInt32 => { write!(f, "UInt32") } DataType::UInt64 => { write!(f, "UInt64") } DataType::UInt128 => { write!(f, "UInt128") } 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::RealUnsigned => write!(f, "REAL UNSIGNED"), DataType::Float4 => write!(f, "FLOAT4"), DataType::Float32 => write!(f, "Float32"), DataType::Float64 => write!(f, "FLOAT64"), DataType::Double(info) => write!(f, "DOUBLE{info}"), DataType::DoubleUnsigned(info) => write!(f, "DOUBLE{info} UNSIGNED"), DataType::Float8 => write!(f, "FLOAT8"), DataType::DoublePrecision => write!(f, "DOUBLE PRECISION"), DataType::DoublePrecisionUnsigned => write!(f, "DOUBLE PRECISION UNSIGNED"), DataType::Bool => write!(f, "BOOL"), DataType::Boolean => write!(f, "BOOLEAN"), DataType::Date => write!(f, "DATE"), DataType::Date32 => write!(f, "Date32"), DataType::Time(precision, timezone_info) => { format_datetime_precision_and_tz(f, "TIME", precision, timezone_info) } DataType::Datetime(precision) => { format_type_with_optional_length(f, "DATETIME", precision, false) } DataType::Timestamp(precision, timezone_info) => { format_datetime_precision_and_tz(f, "TIMESTAMP", precision, timezone_info) } DataType::TimestampNtz(precision) => { format_type_with_optional_length(f, "TIMESTAMP_NTZ", precision, false) } DataType::Datetime64(precision, timezone) => { format_clickhouse_datetime_precision_and_timezone( f, "DateTime64", precision, timezone, ) } DataType::Interval { fields, precision } => { write!(f, "INTERVAL")?; if let Some(fields) = fields { write!(f, " {fields}")?; } if let Some(precision) = precision { write!(f, "({precision})")?; } Ok(()) } DataType::JSON => write!(f, "JSON"), 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}[]"), ArrayElemTypeDef::SquareBracket(t, Some(size)) => write!(f, "{t}[{size}]"), ArrayElemTypeDef::AngleBracket(t) => write!(f, "ARRAY<{t}>"), ArrayElemTypeDef::Parenthesis(t) => write!(f, "Array({t})"), }, DataType::Custom(ty, modifiers) => { if modifiers.is_empty() { write!(f, "{ty}") } else { write!(f, "{}({})", ty, modifiers.join(", ")) } } DataType::Enum(vals, bits) => { match bits { Some(bits) => write!(f, "ENUM{bits}"), None => write!(f, "ENUM"), }?; write!(f, "(")?; 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, ")") } DataType::Set(vals) => { write!(f, "SET(")?; for (i, v) in vals.iter().enumerate() { if i != 0 { write!(f, ", ")?; } write!(f, "'{}'", escape_single_quote_string(v))?; } write!(f, ")") } DataType::Struct(fields, bracket) => { if !fields.is_empty() { match bracket { StructBracketKind::Parentheses => { write!(f, "STRUCT({})", display_comma_separated(fields)) } StructBracketKind::AngleBrackets => { write!(f, "STRUCT<{}>", display_comma_separated(fields)) } } } else { write!(f, "STRUCT") } } DataType::Union(fields) => { write!(f, "UNION({})", display_comma_separated(fields)) } // ClickHouse DataType::Nullable(data_type) => { write!(f, "Nullable({data_type})") } DataType::FixedString(character_length) => { write!(f, "FixedString({character_length})") } DataType::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})") } DataType::Tuple(fields) => { write!(f, "Tuple({})", display_comma_separated(fields)) } DataType::Nested(fields) => { write!(f, "Nested({})", display_comma_separated(fields)) } 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"), } } } fn format_type_with_optional_length( f: &mut fmt::Formatter, sql_type: &'static str, len: &Option, unsigned: bool, ) -> fmt::Result { write!(f, "{sql_type}")?; if let Some(len) = len { write!(f, "({len})")?; } if unsigned { write!(f, " UNSIGNED")?; } Ok(()) } fn format_character_string_type( f: &mut fmt::Formatter, sql_type: &str, size: &Option, ) -> fmt::Result { write!(f, "{sql_type}")?; if let Some(size) = size { write!(f, "({size})")?; } Ok(()) } fn format_varbinary_type( f: &mut fmt::Formatter, sql_type: &str, size: &Option, ) -> 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, len: &Option, time_zone: &TimezoneInfo, ) -> fmt::Result { write!(f, "{sql_type}")?; let len_fmt = len.as_ref().map(|l| format!("({l})")).unwrap_or_default(); match time_zone { TimezoneInfo::Tz => { write!(f, "{time_zone}{len_fmt}")?; } _ => { write!(f, "{len_fmt}{time_zone}")?; } } Ok(()) } fn format_clickhouse_datetime_precision_and_timezone( f: &mut fmt::Formatter, sql_type: &'static str, len: &u64, time_zone: &Option, ) -> fmt::Result { write!(f, "{sql_type}({len}")?; if let Some(time_zone) = time_zone { write!(f, ", '{time_zone}'")?; } write!(f, ")")?; Ok(()) } /// Type of brackets used for `STRUCT` literals. #[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum StructBracketKind { /// Example: `STRUCT(a INT, b STRING)` Parentheses, /// Example: `STRUCT` AngleBrackets, } /// Timestamp and Time data types information about TimeZone formatting. /// /// This is more related to a display information than real differences between each variant. To /// guarantee compatibility with the input query we must maintain its exact information. #[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 TimezoneInfo { /// No information about time zone, e.g. TIMESTAMP None, /// Temporal type 'WITH TIME ZONE', e.g. TIMESTAMP WITH TIME ZONE, [SQL Standard], [Oracle] /// /// [SQL Standard]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#datetime-type /// [Oracle]: https://docs.oracle.com/en/database/oracle/oracle-database/12.2/nlspg/datetime-data-types-and-time-zone-support.html#GUID-3F1C388E-C651-43D5-ADBC-1A49E5C2CA05 WithTimeZone, /// Temporal type 'WITHOUT TIME ZONE', e.g. TIME WITHOUT TIME ZONE, [SQL Standard], [Postgresql] /// /// [SQL Standard]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#datetime-type /// [Postgresql]: https://www.postgresql.org/docs/current/datatype-datetime.html WithoutTimeZone, /// Postgresql specific `WITH TIME ZONE` formatting, for both TIME and TIMESTAMP, e.g. TIMETZ, [Postgresql] /// /// [Postgresql]: https://www.postgresql.org/docs/current/datatype-datetime.html Tz, } impl fmt::Display for TimezoneInfo { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { TimezoneInfo::None => { write!(f, "") } TimezoneInfo::WithTimeZone => { write!(f, " WITH TIME ZONE") } TimezoneInfo::WithoutTimeZone => { write!(f, " WITHOUT TIME ZONE") } TimezoneInfo::Tz => { // TZ is the only one that is displayed BEFORE the precision, so the datatype display // must be aware of that. Check // for more information write!(f, "TZ") } } } } /// Fields for [Postgres] `INTERVAL` type. /// /// [Postgres]: https://www.postgresql.org/docs/17/datatype-datetime.html #[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 IntervalFields { /// `YEAR` field Year, /// `MONTH` field Month, /// `DAY` field Day, /// `HOUR` field Hour, /// `MINUTE` field Minute, /// `SECOND` field Second, /// `YEAR TO MONTH` field YearToMonth, /// `DAY TO HOUR` field DayToHour, /// `DAY TO MINUTE` field DayToMinute, /// `DAY TO SECOND` field DayToSecond, /// `HOUR TO MINUTE` field HourToMinute, /// `HOUR TO SECOND` field HourToSecond, /// `MINUTE TO SECOND` field MinuteToSecond, } impl fmt::Display for IntervalFields { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { IntervalFields::Year => write!(f, "YEAR"), IntervalFields::Month => write!(f, "MONTH"), IntervalFields::Day => write!(f, "DAY"), IntervalFields::Hour => write!(f, "HOUR"), IntervalFields::Minute => write!(f, "MINUTE"), IntervalFields::Second => write!(f, "SECOND"), IntervalFields::YearToMonth => write!(f, "YEAR TO MONTH"), IntervalFields::DayToHour => write!(f, "DAY TO HOUR"), IntervalFields::DayToMinute => write!(f, "DAY TO MINUTE"), IntervalFields::DayToSecond => write!(f, "DAY TO SECOND"), IntervalFields::HourToMinute => write!(f, "HOUR TO MINUTE"), IntervalFields::HourToSecond => write!(f, "HOUR TO SECOND"), IntervalFields::MinuteToSecond => write!(f, "MINUTE TO SECOND"), } } } /// Additional information for `NUMERIC`, `DECIMAL`, and `DEC` data types /// following the 2016 [SQL Standard]. /// /// [SQL Standard]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#exact-numeric-type #[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum ExactNumberInfo { /// No additional information, e.g. `DECIMAL`. None, /// Only precision information, e.g. `DECIMAL(10)`. Precision(u64), /// Precision and scale information, e.g. `DECIMAL(10,2)`. PrecisionAndScale(u64, i64), } impl fmt::Display for ExactNumberInfo { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { ExactNumberInfo::None => { write!(f, "") } ExactNumberInfo::Precision(p) => { write!(f, "({p})") } ExactNumberInfo::PrecisionAndScale(p, s) => { write!(f, "({p},{s})") } } } } /// Information about [character length][1], including length and possibly unit. /// /// [1]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#character-length #[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 CharacterLength { /// Integer length with optional unit (e.g. `CHAR(10)` or `VARCHAR(10 CHARACTERS)`). IntegerLength { /// Default (if VARYING) or maximum (if not VARYING) length length: u64, /// Optional unit. If not informed, the ANSI handles it as CHARACTERS implicitly unit: Option, }, /// VARCHAR(MAX) or NVARCHAR(MAX), used in T-SQL (Microsoft SQL Server). Max, } impl fmt::Display for CharacterLength { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { CharacterLength::IntegerLength { length, unit } => { write!(f, "{length}")?; if let Some(unit) = unit { write!(f, " {unit}")?; } } CharacterLength::Max => { write!(f, "MAX")?; } } Ok(()) } } /// Possible units for characters, initially based on 2016 ANSI [SQL Standard][1]. /// /// [1]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#char-length-units #[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum CharLengthUnits { /// CHARACTERS unit Characters, /// OCTETS unit Octets, } impl fmt::Display for CharLengthUnits { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { Self::Characters => { write!(f, "CHARACTERS") } Self::Octets => { write!(f, "OCTETS") } } } } #[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Information about [binary length][1], including length and possibly unit. /// /// [1]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#binary-length pub enum BinaryLength { /// Integer length for binary types (e.g. `VARBINARY(100)`). 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. /// /// For example: Bigquery/Hive use `ARRAY` whereas snowflake uses ARRAY. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum ArrayElemTypeDef { /// Use `ARRAY` style without an explicit element type. None, /// Angle-bracket style, e.g. `ARRAY`. AngleBracket(Box), /// Square-bracket style, e.g. `INT[]` or `INT[2]`. SquareBracket(Box, Option), /// Parenthesis style, e.g. `Array(Int64)`. Parenthesis(Box), } /// 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 geometry Point, /// Line geometry Line, /// Line segment geometry LineSegment, /// Box geometry GeometricBox, /// Path geometry GeometricPath, /// Polygon geometry Polygon, /// Circle geometry 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"), } } } apache-datafusion-sqlparser-rs-0.62.0/src/ast/dcl.rs000066400000000000000000000447021517524037000223100ustar00rootroot00000000000000// 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. //! AST types specific to GRANT/REVOKE/ROLE variants of [`Statement`](crate::ast::Statement) //! (commonly referred to as Data Control Language, or DCL) #[cfg(not(feature = "std"))] use alloc::vec::Vec; use core::fmt; #[cfg(feature = "serde")] use serde::{Deserialize, Serialize}; #[cfg(feature = "visitor")] use sqlparser_derive::{Visit, VisitMut}; use super::{display_comma_separated, Expr, Ident, Password, Spanned}; use crate::ast::{ display_separated, CascadeOption, CurrentGrantsKind, GrantObjects, Grantee, ObjectName, Privileges, }; use crate::tokenizer::Span; /// An option in `ROLE` statement. /// /// #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum RoleOption { /// Enable or disable BYPASSRLS. BypassRLS(bool), /// Connection limit expression. ConnectionLimit(Expr), /// CREATEDB flag. CreateDB(bool), /// CREATEROLE flag. CreateRole(bool), /// INHERIT flag. Inherit(bool), /// LOGIN flag. Login(bool), /// Password value or NULL password. Password(Password), /// Replication privilege flag. Replication(bool), /// SUPERUSER flag. SuperUser(bool), /// `VALID UNTIL` expression. ValidUntil(Expr), } impl fmt::Display for RoleOption { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { RoleOption::BypassRLS(value) => { write!(f, "{}", if *value { "BYPASSRLS" } else { "NOBYPASSRLS" }) } RoleOption::ConnectionLimit(expr) => { write!(f, "CONNECTION LIMIT {expr}") } RoleOption::CreateDB(value) => { write!(f, "{}", if *value { "CREATEDB" } else { "NOCREATEDB" }) } RoleOption::CreateRole(value) => { write!(f, "{}", if *value { "CREATEROLE" } else { "NOCREATEROLE" }) } RoleOption::Inherit(value) => { write!(f, "{}", if *value { "INHERIT" } else { "NOINHERIT" }) } RoleOption::Login(value) => { write!(f, "{}", if *value { "LOGIN" } else { "NOLOGIN" }) } RoleOption::Password(password) => match password { Password::Password(expr) => write!(f, "PASSWORD {expr}"), Password::NullPassword => write!(f, "PASSWORD NULL"), }, RoleOption::Replication(value) => { write!( f, "{}", if *value { "REPLICATION" } else { "NOREPLICATION" } ) } RoleOption::SuperUser(value) => { write!(f, "{}", if *value { "SUPERUSER" } else { "NOSUPERUSER" }) } RoleOption::ValidUntil(expr) => { write!(f, "VALID UNTIL {expr}") } } } } /// SET config value option: /// * SET `configuration_parameter` { TO | = } { `value` | DEFAULT } /// * SET `configuration_parameter` FROM CURRENT #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum SetConfigValue { /// Use the default value. Default, /// Use the current value (`FROM CURRENT`). FromCurrent, /// Set to the provided expression value. Value(Expr), } /// RESET config option: /// * RESET `configuration_parameter` /// * RESET ALL #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum ResetConfig { /// Reset all configuration parameters. ALL, /// Reset the named configuration parameter. ConfigName(ObjectName), } /// An `ALTER ROLE` (`Statement::AlterRole`) operation #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum AlterRoleOperation { /// Generic RenameRole { /// Role name to rename. role_name: Ident, }, /// MS SQL Server /// AddMember { /// Member name to add to the role. member_name: Ident, }, /// MS SQL Server /// /// DropMember { /// Member name to remove from the role. member_name: Ident, }, /// PostgreSQL /// WithOptions { /// Role options to apply. options: Vec, }, /// PostgreSQL /// /// /// `SET configuration_parameter { TO | = } { value | DEFAULT }` Set { /// Configuration name to set. config_name: ObjectName, /// Value to assign to the configuration. config_value: SetConfigValue, /// Optional database scope for the setting. in_database: Option, }, /// PostgreSQL /// /// /// `RESET configuration_parameter` | `RESET ALL` Reset { /// Configuration to reset. config_name: ResetConfig, /// Optional database scope for the reset. in_database: Option, }, } impl fmt::Display for AlterRoleOperation { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { AlterRoleOperation::RenameRole { role_name } => { write!(f, "RENAME TO {role_name}") } AlterRoleOperation::AddMember { member_name } => { write!(f, "ADD MEMBER {member_name}") } AlterRoleOperation::DropMember { member_name } => { write!(f, "DROP MEMBER {member_name}") } AlterRoleOperation::WithOptions { options } => { write!(f, "WITH {}", display_separated(options, " ")) } AlterRoleOperation::Set { config_name, config_value, in_database, } => { if let Some(database_name) = in_database { write!(f, "IN DATABASE {database_name} ")?; } match config_value { SetConfigValue::Default => write!(f, "SET {config_name} TO DEFAULT"), SetConfigValue::FromCurrent => write!(f, "SET {config_name} FROM CURRENT"), SetConfigValue::Value(expr) => write!(f, "SET {config_name} TO {expr}"), } } AlterRoleOperation::Reset { config_name, in_database, } => { if let Some(database_name) = in_database { write!(f, "IN DATABASE {database_name} ")?; } match config_name { ResetConfig::ALL => write!(f, "RESET ALL"), ResetConfig::ConfigName(name) => write!(f, "RESET {name}"), } } } } } /// A `USE` (`Statement::Use`) operation #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum Use { /// Switch to the given catalog (e.g. `USE CATALOG ...`). Catalog(ObjectName), /// Switch to the given schema (e.g. `USE SCHEMA ...`). Schema(ObjectName), /// Switch to the given database (e.g. `USE DATABASE ...`). Database(ObjectName), /// Switch to the given warehouse (e.g. `USE WAREHOUSE ...`). Warehouse(ObjectName), /// Switch to the given role (e.g. `USE ROLE ...`). Role(ObjectName), /// Use secondary roles specification (e.g. `USE SECONDARY ROLES ...`). SecondaryRoles(SecondaryRoles), /// Use the specified object (e.g. `USE foo.bar`). Object(ObjectName), /// Reset to default (e.g. `USE DEFAULT`). 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::Default => write!(f, "DEFAULT"), } } } /// Snowflake `SECONDARY ROLES` USE variant /// See: #[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 { /// Use all secondary roles. All, /// Use no secondary roles. None, /// Explicit list of secondary roles. List(Vec), } 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)), } } } /// CREATE ROLE statement /// See [PostgreSQL](https://www.postgresql.org/docs/current/sql-createrole.html) #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct CreateRole { /// Role names to create. pub names: Vec, /// Whether `IF NOT EXISTS` was specified. pub if_not_exists: bool, // Postgres /// Whether `LOGIN` was specified. pub login: Option, /// Whether `INHERIT` was specified. pub inherit: Option, /// Whether `BYPASSRLS` was specified. pub bypassrls: Option, /// Optional password for the role. pub password: Option, /// Whether `SUPERUSER` was specified. pub superuser: Option, /// Whether `CREATEDB` was specified. pub create_db: Option, /// Whether `CREATEROLE` was specified. pub create_role: Option, /// Whether `REPLICATION` privilege was specified. pub replication: Option, /// Optional connection limit expression. pub connection_limit: Option, /// Optional account validity expression. pub valid_until: Option, /// Members of `IN ROLE` clause. pub in_role: Vec, /// Members of `IN GROUP` clause. pub in_group: Vec, /// Roles listed in `ROLE` clause. pub role: Vec, /// Users listed in `USER` clause. pub user: Vec, /// Admin users listed in `ADMIN` clause. pub admin: Vec, // MSSQL /// Optional authorization owner. pub authorization_owner: Option, } impl fmt::Display for CreateRole { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "CREATE ROLE {if_not_exists}{names}{superuser}{create_db}{create_role}{inherit}{login}{replication}{bypassrls}", if_not_exists = if self.if_not_exists { "IF NOT EXISTS " } else { "" }, names = display_separated(&self.names, ", "), superuser = match self.superuser { Some(true) => " SUPERUSER", Some(false) => " NOSUPERUSER", None => "" }, create_db = match self.create_db { Some(true) => " CREATEDB", Some(false) => " NOCREATEDB", None => "" }, create_role = match self.create_role { Some(true) => " CREATEROLE", Some(false) => " NOCREATEROLE", None => "" }, inherit = match self.inherit { Some(true) => " INHERIT", Some(false) => " NOINHERIT", None => "" }, login = match self.login { Some(true) => " LOGIN", Some(false) => " NOLOGIN", None => "" }, replication = match self.replication { Some(true) => " REPLICATION", Some(false) => " NOREPLICATION", None => "" }, bypassrls = match self.bypassrls { Some(true) => " BYPASSRLS", Some(false) => " NOBYPASSRLS", None => "" } )?; if let Some(limit) = &self.connection_limit { write!(f, " CONNECTION LIMIT {limit}")?; } match &self.password { Some(Password::Password(pass)) => write!(f, " PASSWORD {pass}")?, Some(Password::NullPassword) => write!(f, " PASSWORD NULL")?, None => {} }; if let Some(until) = &self.valid_until { write!(f, " VALID UNTIL {until}")?; } if !self.in_role.is_empty() { write!(f, " IN ROLE {}", display_comma_separated(&self.in_role))?; } if !self.in_group.is_empty() { write!(f, " IN GROUP {}", display_comma_separated(&self.in_group))?; } if !self.role.is_empty() { write!(f, " ROLE {}", display_comma_separated(&self.role))?; } if !self.user.is_empty() { write!(f, " USER {}", display_comma_separated(&self.user))?; } if !self.admin.is_empty() { write!(f, " ADMIN {}", display_comma_separated(&self.admin))?; } if let Some(owner) = &self.authorization_owner { write!(f, " AUTHORIZATION {owner}")?; } Ok(()) } } impl Spanned for CreateRole { fn span(&self) -> Span { Span::empty() } } /// GRANT privileges ON objects TO grantees #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct Grant { /// Privileges being granted. pub privileges: Privileges, /// Optional objects the privileges apply to. pub objects: Option, /// List of grantees receiving the privileges. pub grantees: Vec, /// Whether `WITH GRANT OPTION` is present. pub with_grant_option: bool, /// Optional `AS GRANTOR` identifier. pub as_grantor: Option, /// Optional `GRANTED BY` identifier. /// /// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/dcl-statements) pub granted_by: Option, /// Optional `CURRENT GRANTS` modifier. /// /// [Snowflake](https://docs.snowflake.com/en/sql-reference/sql/grant-privilege) pub current_grants: Option, } impl fmt::Display for Grant { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "GRANT {privileges}", privileges = self.privileges)?; if let Some(ref objects) = self.objects { write!(f, " ON {objects}")?; } write!(f, " TO {}", display_comma_separated(&self.grantees))?; if let Some(ref current_grants) = self.current_grants { write!(f, " {current_grants}")?; } if self.with_grant_option { write!(f, " WITH GRANT OPTION")?; } if let Some(ref as_grantor) = self.as_grantor { write!(f, " AS {as_grantor}")?; } if let Some(ref granted_by) = self.granted_by { write!(f, " GRANTED BY {granted_by}")?; } Ok(()) } } impl From for crate::ast::Statement { fn from(v: Grant) -> Self { crate::ast::Statement::Grant(v) } } /// REVOKE privileges ON objects FROM grantees #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct Revoke { /// Privileges to revoke. pub privileges: Privileges, /// Optional objects from which to revoke. pub objects: Option, /// Grantees affected by the revoke. pub grantees: Vec, /// Optional `GRANTED BY` identifier. /// /// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/dcl-statements) pub granted_by: Option, /// Optional `CASCADE`/`RESTRICT` behavior. pub cascade: Option, } impl fmt::Display for Revoke { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "REVOKE {privileges}", privileges = self.privileges)?; if let Some(ref objects) = self.objects { write!(f, " ON {objects}")?; } write!(f, " FROM {}", display_comma_separated(&self.grantees))?; if let Some(ref granted_by) = self.granted_by { write!(f, " GRANTED BY {granted_by}")?; } if let Some(ref cascade) = self.cascade { write!(f, " {cascade}")?; } Ok(()) } } impl From for crate::ast::Statement { fn from(v: Revoke) -> Self { crate::ast::Statement::Revoke(v) } } apache-datafusion-sqlparser-rs-0.62.0/src/ast/ddl.rs000066400000000000000000006352031517524037000223130ustar00rootroot00000000000000// 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. //! AST types specific to CREATE/ALTER variants of [`Statement`](crate::ast::Statement) //! (commonly referred to as Data Definition Language, or DDL) #[cfg(not(feature = "std"))] use alloc::{ boxed::Box, format, string::{String, ToString}, vec, vec::Vec, }; use core::fmt::{self, Display, Write}; #[cfg(feature = "serde")] use serde::{Deserialize, Serialize}; #[cfg(feature = "visitor")] use sqlparser_derive::{Visit, VisitMut}; use crate::ast::value::escape_single_quote_string; use crate::ast::{ display_comma_separated, display_separated, table_constraints::{ CheckConstraint, ForeignKeyConstraint, PrimaryKeyConstraint, TableConstraint, UniqueConstraint, }, ArgMode, AttachedToken, CommentDef, ConditionalStatements, CreateFunctionBody, CreateFunctionUsing, CreateTableLikeKind, CreateTableOptions, CreateViewParams, DataType, Expr, FileFormat, FunctionBehavior, FunctionCalledOnNull, FunctionDefinitionSetParam, FunctionDesc, FunctionDeterminismSpecifier, FunctionParallel, FunctionSecurity, HiveDistributionStyle, HiveFormat, HiveIOFormat, HiveRowFormat, HiveSetLocation, Ident, InitializeKind, MySQLColumnPosition, ObjectName, OnCommit, OneOrManyWithParens, OperateFunctionArg, OrderByExpr, ProjectionSelect, Query, RefreshModeKind, ResetConfig, RowAccessPolicy, SequenceOptions, Spanned, SqlOption, StorageLifecyclePolicy, StorageSerializationPolicy, TableVersion, Tag, TriggerEvent, TriggerExecBody, TriggerObject, TriggerPeriod, TriggerReferencing, Value, ValueWithSpan, WrappedCollection, }; use crate::display_utils::{DisplayCommaSeparated, Indent, NewLine, SpaceOrNewline}; use crate::keywords::Keyword; use crate::tokenizer::{Span, Token}; /// 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 { /// The indexed column expression. pub column: OrderByExpr, /// Optional operator class (index operator name). pub operator_class: Option, } impl From for IndexColumn { fn from(c: Ident) -> Self { Self { column: OrderByExpr::from(c), operator_class: None, } } } impl<'a> From<&'a str> for IndexColumn { fn from(c: &'a str) -> Self { let ident = Ident::new(c); ident.into() } } impl fmt::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(()) } } /// ALTER TABLE operation REPLICA IDENTITY values /// See [Postgres ALTER TABLE docs](https://www.postgresql.org/docs/current/sql-altertable.html) #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum ReplicaIdentity { /// No replica identity (`REPLICA IDENTITY NOTHING`). Nothing, /// Full replica identity (`REPLICA IDENTITY FULL`). Full, /// Default replica identity (`REPLICA IDENTITY DEFAULT`). Default, /// Use the given index as replica identity (`REPLICA IDENTITY USING INDEX`). Index(Ident), } impl fmt::Display for ReplicaIdentity { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { ReplicaIdentity::Nothing => f.write_str("NOTHING"), ReplicaIdentity::Full => f.write_str("FULL"), ReplicaIdentity::Default => f.write_str("DEFAULT"), ReplicaIdentity::Index(idx) => write!(f, "USING INDEX {idx}"), } } } /// An `ALTER TABLE` (`Statement::AlterTable`) operation #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum AlterTableOperation { /// `ADD [NOT VALID]` AddConstraint { /// The table constraint to add. constraint: TableConstraint, /// Whether the constraint should be marked `NOT VALID`. not_valid: bool, }, /// `ADD [COLUMN] [IF NOT EXISTS] ` AddColumn { /// `[COLUMN]`. column_keyword: bool, /// `[IF NOT EXISTS]` if_not_exists: bool, /// . column_def: ColumnDef, /// MySQL `ALTER TABLE` only [FIRST | AFTER column_name] column_position: Option, }, /// `ADD PROJECTION [IF NOT EXISTS] name ( SELECT [GROUP BY] [ORDER BY])` /// /// Note: this is a ClickHouse-specific operation. /// Please refer to [ClickHouse](https://clickhouse.com/docs/en/sql-reference/statements/alter/projection#add-projection) AddProjection { /// Whether `IF NOT EXISTS` was specified. if_not_exists: bool, /// Name of the projection to add. name: Ident, /// The projection's select clause. select: ProjectionSelect, }, /// `DROP PROJECTION [IF EXISTS] name` /// /// Note: this is a ClickHouse-specific operation. /// Please refer to [ClickHouse](https://clickhouse.com/docs/en/sql-reference/statements/alter/projection#drop-projection) DropProjection { /// Whether `IF EXISTS` was specified. if_exists: bool, /// Name of the projection to drop. name: Ident, }, /// `MATERIALIZE PROJECTION [IF EXISTS] name [IN PARTITION partition_name]` /// /// Note: this is a ClickHouse-specific operation. /// Please refer to [ClickHouse](https://clickhouse.com/docs/en/sql-reference/statements/alter/projection#materialize-projection) MaterializeProjection { /// Whether `IF EXISTS` was specified. if_exists: bool, /// Name of the projection to materialize. name: Ident, /// Optional partition name to operate on. partition: Option, }, /// `CLEAR PROJECTION [IF EXISTS] name [IN PARTITION partition_name]` /// /// Note: this is a ClickHouse-specific operation. /// Please refer to [ClickHouse](https://clickhouse.com/docs/en/sql-reference/statements/alter/projection#clear-projection) ClearProjection { /// Whether `IF EXISTS` was specified. if_exists: bool, /// Name of the projection to clear. name: Ident, /// Optional partition name to operate on. partition: Option, }, /// `DISABLE ROW LEVEL SECURITY` /// /// Note: this is a PostgreSQL-specific operation. /// Please refer to [PostgreSQL documentation](https://www.postgresql.org/docs/current/sql-altertable.html) DisableRowLevelSecurity, /// `DISABLE RULE rewrite_rule_name` /// /// Note: this is a PostgreSQL-specific operation. DisableRule { /// Name of the rule to disable. name: Ident, }, /// `DISABLE TRIGGER [ trigger_name | ALL | USER ]` /// /// Note: this is a PostgreSQL-specific operation. DisableTrigger { /// Name of the trigger to disable (or ALL/USER). name: Ident, }, /// `DROP CONSTRAINT [ IF EXISTS ] ` DropConstraint { /// `IF EXISTS` flag for dropping the constraint. if_exists: bool, /// Name of the constraint to drop. name: Ident, /// Optional drop behavior (`CASCADE`/`RESTRICT`). drop_behavior: Option, }, /// `DROP [ COLUMN ] [ IF EXISTS ] [ , , ... ] [ CASCADE ]` DropColumn { /// Whether the `COLUMN` keyword was present. has_column_keyword: bool, /// Names of columns to drop. column_names: Vec, /// Whether `IF EXISTS` was specified for the columns. if_exists: bool, /// Optional drop behavior for the column removal. drop_behavior: Option, }, /// `ATTACH PART|PARTITION ` /// Note: this is a ClickHouse-specific operation, please refer to /// [ClickHouse](https://clickhouse.com/docs/en/sql-reference/statements/alter/partition#attach-partitionpart) AttachPartition { // PART is not a short form of PARTITION, it's a separate keyword // which represents a physical file on disk and partition is a logical entity. /// Partition expression to attach. partition: Partition, }, /// `DETACH PART|PARTITION ` /// Note: this is a ClickHouse-specific operation, please refer to /// [ClickHouse](https://clickhouse.com/docs/en/sql-reference/statements/alter/partition#detach-partitionpart) DetachPartition { // See `AttachPartition` for more details /// Partition expression to detach. partition: Partition, }, /// `FREEZE PARTITION ` /// Note: this is a ClickHouse-specific operation, please refer to /// [ClickHouse](https://clickhouse.com/docs/en/sql-reference/statements/alter/partition#freeze-partition) FreezePartition { /// Partition to freeze. partition: Partition, /// Optional name for the freeze operation. with_name: Option, }, /// `UNFREEZE PARTITION ` /// Note: this is a ClickHouse-specific operation, please refer to /// [ClickHouse](https://clickhouse.com/docs/en/sql-reference/statements/alter/partition#unfreeze-partition) UnfreezePartition { /// Partition to unfreeze. partition: Partition, /// Optional name associated with the unfreeze operation. with_name: Option, }, /// `DROP PRIMARY KEY` /// /// [MySQL](https://dev.mysql.com/doc/refman/8.4/en/alter-table.html) /// [Snowflake](https://docs.snowflake.com/en/sql-reference/constraints-drop) DropPrimaryKey { /// Optional drop behavior for the primary key (`CASCADE`/`RESTRICT`). drop_behavior: Option, }, /// `DROP FOREIGN KEY ` /// /// [MySQL](https://dev.mysql.com/doc/refman/8.4/en/alter-table.html) /// [Snowflake](https://docs.snowflake.com/en/sql-reference/constraints-drop) DropForeignKey { /// Foreign key symbol/name to drop. name: Ident, /// Optional drop behavior for the foreign key. drop_behavior: Option, }, /// `DROP INDEX ` /// /// [MySQL]: https://dev.mysql.com/doc/refman/8.4/en/alter-table.html DropIndex { /// Name of the index to drop. name: Ident, }, /// `ENABLE ALWAYS RULE rewrite_rule_name` /// /// Note: this is a PostgreSQL-specific operation. EnableAlwaysRule { /// Name of the rule to enable. name: Ident, }, /// `ENABLE ALWAYS TRIGGER trigger_name` /// /// Note: this is a PostgreSQL-specific operation. EnableAlwaysTrigger { /// Name of the trigger to enable. name: Ident, }, /// `ENABLE REPLICA RULE rewrite_rule_name` /// /// Note: this is a PostgreSQL-specific operation. EnableReplicaRule { /// Name of the replica rule to enable. name: Ident, }, /// `ENABLE REPLICA TRIGGER trigger_name` /// /// Note: this is a PostgreSQL-specific operation. EnableReplicaTrigger { /// Name of the replica trigger to enable. name: Ident, }, /// `ENABLE ROW LEVEL SECURITY` /// /// Note: this is a PostgreSQL-specific operation. /// Please refer to [PostgreSQL documentation](https://www.postgresql.org/docs/current/sql-altertable.html) EnableRowLevelSecurity, /// `FORCE ROW LEVEL SECURITY` /// /// Note: this is a PostgreSQL-specific operation. /// Please refer to [PostgreSQL documentation](https://www.postgresql.org/docs/current/sql-altertable.html) ForceRowLevelSecurity, /// `NO FORCE ROW LEVEL SECURITY` /// /// Note: this is a PostgreSQL-specific operation. /// Please refer to [PostgreSQL documentation](https://www.postgresql.org/docs/current/sql-altertable.html) NoForceRowLevelSecurity, /// `ENABLE RULE rewrite_rule_name` /// /// Note: this is a PostgreSQL-specific operation. EnableRule { /// Name of the rule to enable. name: Ident, }, /// `ENABLE TRIGGER [ trigger_name | ALL | USER ]` /// /// Note: this is a PostgreSQL-specific operation. EnableTrigger { /// Name of the trigger to enable (or ALL/USER). name: Ident, }, /// `RENAME TO PARTITION (partition=val)` RenamePartitions { /// Old partition expressions to be renamed. old_partitions: Vec, /// New partition expressions corresponding to the old ones. new_partitions: Vec, }, /// REPLICA IDENTITY { DEFAULT | USING INDEX index_name | FULL | NOTHING } /// /// Note: this is a PostgreSQL-specific operation. /// Please refer to [PostgreSQL documentation](https://www.postgresql.org/docs/current/sql-altertable.html) ReplicaIdentity { /// Replica identity setting to apply. identity: ReplicaIdentity, }, /// Add Partitions AddPartitions { /// Whether `IF NOT EXISTS` was present when adding partitions. if_not_exists: bool, /// New partitions to add. new_partitions: Vec, }, /// `DROP PARTITIONS ...` / drop partitions from the table. DropPartitions { /// Partitions to drop (expressions). partitions: Vec, /// Whether `IF EXISTS` was specified for dropping partitions. if_exists: bool, }, /// `RENAME [ COLUMN ] TO ` RenameColumn { /// Existing column name to rename. old_column_name: Ident, /// New column name. new_column_name: Ident, }, /// `RENAME TO ` RenameTable { /// The new table name or renaming kind. table_name: RenameTableNameKind, }, // CHANGE [ COLUMN ] [ ] /// Change an existing column's name, type, and options. ChangeColumn { /// Old column name. old_name: Ident, /// New column name. new_name: Ident, /// New data type for the column. data_type: DataType, /// Column options to apply after the change. options: Vec, /// MySQL-specific column position (`FIRST`/`AFTER`). column_position: Option, }, // CHANGE [ COLUMN ] [ ] /// Modify an existing column's type and options. ModifyColumn { /// Column name to modify. col_name: Ident, /// New data type for the column. data_type: DataType, /// Column options to set. options: Vec, /// MySQL-specific column position (`FIRST`/`AFTER`). column_position: Option, }, /// `RENAME CONSTRAINT TO ` /// /// Note: this is a PostgreSQL-specific operation. /// Rename a constraint on the table. RenameConstraint { /// Existing constraint name. old_name: Ident, /// New constraint name. new_name: Ident, }, /// `ALTER [ COLUMN ]` /// Alter a specific column with the provided operation. AlterColumn { /// The column to alter. column_name: Ident, /// Operation to apply to the column. op: AlterColumnOperation, }, /// 'SWAP WITH ' /// /// Note: this is Snowflake specific SwapWith { /// Table name to swap with. table_name: ObjectName, }, /// 'SET TBLPROPERTIES ( { property_key [ = ] property_val } [, ...] )' SetTblProperties { /// Table properties specified as SQL options. table_properties: Vec, }, /// `OWNER TO { | CURRENT_ROLE | CURRENT_USER | SESSION_USER }` /// /// Note: this is PostgreSQL-specific OwnerTo { /// The new owner to assign to the table. new_owner: Owner, }, /// Snowflake table clustering options /// ClusterBy { /// Expressions used for clustering the table. exprs: Vec, }, /// Remove the clustering key from the table. DropClusteringKey, /// Redshift `ALTER SORTKEY (column_list)` /// AlterSortKey { /// Column references in the sort key. columns: Vec, }, /// Suspend background reclustering operations. SuspendRecluster, /// Resume background reclustering operations. ResumeRecluster, /// `REFRESH [ '' ]` /// /// Note: this is Snowflake specific for dynamic/external tables /// /// Refresh { /// Optional subpath for external table refresh subpath: Option, }, /// `SUSPEND` /// /// Note: this is Snowflake specific for dynamic tables Suspend, /// `RESUME` /// /// Note: this is Snowflake specific for dynamic tables Resume, /// `ALGORITHM [=] { DEFAULT | INSTANT | INPLACE | COPY }` /// /// [MySQL]-specific table alter algorithm. /// /// [MySQL]: https://dev.mysql.com/doc/refman/8.4/en/alter-table.html Algorithm { /// Whether the `=` sign was used (`ALGORITHM = ...`). equals: bool, /// The algorithm to use for the alter operation (MySQL-specific). algorithm: AlterTableAlgorithm, }, /// `LOCK [=] { DEFAULT | NONE | SHARED | EXCLUSIVE }` /// /// [MySQL]-specific table alter lock. /// /// [MySQL]: https://dev.mysql.com/doc/refman/8.4/en/alter-table.html Lock { /// Whether the `=` sign was used (`LOCK = ...`). equals: bool, /// The locking behavior to apply (MySQL-specific). lock: AlterTableLock, }, /// `AUTO_INCREMENT [=] ` /// /// [MySQL]-specific table option for raising current auto increment value. /// /// [MySQL]: https://dev.mysql.com/doc/refman/8.4/en/alter-table.html AutoIncrement { /// Whether the `=` sign was used (`AUTO_INCREMENT = ...`). equals: bool, /// Value to set for the auto-increment counter. value: ValueWithSpan, }, /// `VALIDATE CONSTRAINT ` ValidateConstraint { /// Name of the constraint to validate. name: Ident, }, /// Arbitrary parenthesized `SET` options. /// /// Example: /// ```sql /// SET (scale_factor = 0.01, threshold = 500)` /// ``` /// [PostgreSQL](https://www.postgresql.org/docs/current/sql-altertable.html) SetOptionsParens { /// Parenthesized options supplied to `SET (...)`. options: Vec, }, } /// An `ALTER Policy` (`Statement::AlterPolicy`) operation /// /// [PostgreSQL Documentation](https://www.postgresql.org/docs/current/sql-altertable.html) #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum AlterPolicyOperation { /// Rename the policy to `new_name`. Rename { /// The new identifier for the policy. new_name: Ident, }, /// Apply/modify policy properties. Apply { /// Optional list of owners the policy applies to. to: Option>, /// Optional `USING` expression for the policy. using: Option, /// Optional `WITH CHECK` expression for the policy. with_check: Option, }, } impl fmt::Display for AlterPolicyOperation { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { AlterPolicyOperation::Rename { new_name } => { write!(f, " RENAME TO {new_name}") } AlterPolicyOperation::Apply { to, using, with_check, } => { if let Some(to) = to { write!(f, " TO {}", display_comma_separated(to))?; } if let Some(using) = using { write!(f, " USING ({using})")?; } if let Some(with_check) = with_check { write!(f, " WITH CHECK ({with_check})")?; } Ok(()) } } } } /// [MySQL] `ALTER TABLE` algorithm. /// /// [MySQL]: https://dev.mysql.com/doc/refman/8.4/en/alter-table.html #[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Algorithm option for `ALTER TABLE` operations (MySQL-specific). pub enum AlterTableAlgorithm { /// Default algorithm selection. Default, /// `INSTANT` algorithm. Instant, /// `INPLACE` algorithm. Inplace, /// `COPY` algorithm. Copy, } impl fmt::Display for AlterTableAlgorithm { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str(match self { Self::Default => "DEFAULT", Self::Instant => "INSTANT", Self::Inplace => "INPLACE", Self::Copy => "COPY", }) } } /// [MySQL] `ALTER TABLE` lock. /// /// [MySQL]: https://dev.mysql.com/doc/refman/8.4/en/alter-table.html #[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Locking behavior for `ALTER TABLE` (MySQL-specific). pub enum AlterTableLock { /// `DEFAULT` lock behavior. Default, /// `NONE` lock. None, /// `SHARED` lock. Shared, /// `EXCLUSIVE` lock. Exclusive, } impl fmt::Display for AlterTableLock { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str(match self { Self::Default => "DEFAULT", Self::None => "NONE", Self::Shared => "SHARED", Self::Exclusive => "EXCLUSIVE", }) } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// New owner specification for `ALTER TABLE ... OWNER TO ...` pub enum Owner { /// A specific user/role identifier. Ident(Ident), /// `CURRENT_ROLE` keyword. CurrentRole, /// `CURRENT_USER` keyword. CurrentUser, /// `SESSION_USER` keyword. SessionUser, } impl fmt::Display for Owner { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { Owner::Ident(ident) => write!(f, "{ident}"), Owner::CurrentRole => write!(f, "CURRENT_ROLE"), Owner::CurrentUser => write!(f, "CURRENT_USER"), Owner::SessionUser => write!(f, "SESSION_USER"), } } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// New connector owner specification for `ALTER CONNECTOR ... OWNER TO ...` pub enum AlterConnectorOwner { /// `USER ` connector owner. User(Ident), /// `ROLE ` connector owner. Role(Ident), } impl fmt::Display for AlterConnectorOwner { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { AlterConnectorOwner::User(ident) => write!(f, "USER {ident}"), AlterConnectorOwner::Role(ident) => write!(f, "ROLE {ident}"), } } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Alterations that can be applied to an index. pub enum AlterIndexOperation { /// Rename the index to `index_name`. RenameIndex { /// The new name for the index. index_name: ObjectName, }, } impl fmt::Display for AlterTableOperation { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { AlterTableOperation::AddPartitions { if_not_exists, new_partitions, } => write!( f, "ADD{ine} {}", display_separated(new_partitions, " "), ine = if *if_not_exists { " IF NOT EXISTS" } else { "" } ), AlterTableOperation::AddConstraint { not_valid, constraint, } => { write!(f, "ADD {constraint}")?; if *not_valid { write!(f, " NOT VALID")?; } Ok(()) } AlterTableOperation::AddColumn { column_keyword, if_not_exists, column_def, column_position, } => { write!(f, "ADD")?; if *column_keyword { write!(f, " COLUMN")?; } if *if_not_exists { write!(f, " IF NOT EXISTS")?; } write!(f, " {column_def}")?; if let Some(position) = column_position { write!(f, " {position}")?; } Ok(()) } AlterTableOperation::AddProjection { if_not_exists, name, select: query, } => { write!(f, "ADD PROJECTION")?; if *if_not_exists { write!(f, " IF NOT EXISTS")?; } write!(f, " {name} ({query})") } AlterTableOperation::Algorithm { equals, algorithm } => { write!( f, "ALGORITHM {}{}", if *equals { "= " } else { "" }, algorithm ) } AlterTableOperation::DropProjection { if_exists, name } => { write!(f, "DROP PROJECTION")?; if *if_exists { write!(f, " IF EXISTS")?; } write!(f, " {name}") } AlterTableOperation::MaterializeProjection { if_exists, name, partition, } => { write!(f, "MATERIALIZE PROJECTION")?; if *if_exists { write!(f, " IF EXISTS")?; } write!(f, " {name}")?; if let Some(partition) = partition { write!(f, " IN PARTITION {partition}")?; } Ok(()) } AlterTableOperation::ClearProjection { if_exists, name, partition, } => { write!(f, "CLEAR PROJECTION")?; if *if_exists { write!(f, " IF EXISTS")?; } write!(f, " {name}")?; if let Some(partition) = partition { write!(f, " IN PARTITION {partition}")?; } Ok(()) } AlterTableOperation::AlterColumn { column_name, op } => { write!(f, "ALTER COLUMN {column_name} {op}") } AlterTableOperation::DisableRowLevelSecurity => { write!(f, "DISABLE ROW LEVEL SECURITY") } AlterTableOperation::DisableRule { name } => { write!(f, "DISABLE RULE {name}") } AlterTableOperation::DisableTrigger { name } => { write!(f, "DISABLE TRIGGER {name}") } AlterTableOperation::DropPartitions { partitions, if_exists, } => write!( f, "DROP{ie} PARTITION ({})", display_comma_separated(partitions), ie = if *if_exists { " IF EXISTS" } else { "" } ), AlterTableOperation::DropConstraint { if_exists, name, drop_behavior, } => { write!( f, "DROP CONSTRAINT {}{}", if *if_exists { "IF EXISTS " } else { "" }, name )?; if let Some(drop_behavior) = drop_behavior { write!(f, " {drop_behavior}")?; } Ok(()) } AlterTableOperation::DropPrimaryKey { drop_behavior } => { write!(f, "DROP PRIMARY KEY")?; if let Some(drop_behavior) = drop_behavior { write!(f, " {drop_behavior}")?; } Ok(()) } AlterTableOperation::DropForeignKey { name, drop_behavior, } => { write!(f, "DROP FOREIGN KEY {name}")?; if let Some(drop_behavior) = drop_behavior { write!(f, " {drop_behavior}")?; } Ok(()) } AlterTableOperation::DropIndex { name } => write!(f, "DROP INDEX {name}"), AlterTableOperation::DropColumn { has_column_keyword, column_names: column_name, if_exists, drop_behavior, } => { write!( f, "DROP {}{}{}", if *has_column_keyword { "COLUMN " } else { "" }, if *if_exists { "IF EXISTS " } else { "" }, display_comma_separated(column_name), )?; if let Some(drop_behavior) = drop_behavior { write!(f, " {drop_behavior}")?; } Ok(()) } AlterTableOperation::AttachPartition { partition } => { write!(f, "ATTACH {partition}") } AlterTableOperation::DetachPartition { partition } => { write!(f, "DETACH {partition}") } AlterTableOperation::EnableAlwaysRule { name } => { write!(f, "ENABLE ALWAYS RULE {name}") } AlterTableOperation::EnableAlwaysTrigger { name } => { write!(f, "ENABLE ALWAYS TRIGGER {name}") } AlterTableOperation::EnableReplicaRule { name } => { write!(f, "ENABLE REPLICA RULE {name}") } AlterTableOperation::EnableReplicaTrigger { name } => { write!(f, "ENABLE REPLICA TRIGGER {name}") } AlterTableOperation::EnableRowLevelSecurity => { write!(f, "ENABLE ROW LEVEL SECURITY") } AlterTableOperation::ForceRowLevelSecurity => { write!(f, "FORCE ROW LEVEL SECURITY") } AlterTableOperation::NoForceRowLevelSecurity => { write!(f, "NO FORCE ROW LEVEL SECURITY") } AlterTableOperation::EnableRule { name } => { write!(f, "ENABLE RULE {name}") } AlterTableOperation::EnableTrigger { name } => { write!(f, "ENABLE TRIGGER {name}") } AlterTableOperation::RenamePartitions { old_partitions, new_partitions, } => write!( f, "PARTITION ({}) RENAME TO PARTITION ({})", display_comma_separated(old_partitions), display_comma_separated(new_partitions) ), AlterTableOperation::RenameColumn { old_column_name, new_column_name, } => write!(f, "RENAME COLUMN {old_column_name} TO {new_column_name}"), AlterTableOperation::RenameTable { table_name } => { write!(f, "RENAME {table_name}") } AlterTableOperation::ChangeColumn { old_name, new_name, data_type, options, column_position, } => { write!(f, "CHANGE COLUMN {old_name} {new_name} {data_type}")?; if !options.is_empty() { write!(f, " {}", display_separated(options, " "))?; } if let Some(position) = column_position { write!(f, " {position}")?; } Ok(()) } AlterTableOperation::ModifyColumn { col_name, data_type, options, column_position, } => { write!(f, "MODIFY COLUMN {col_name} {data_type}")?; if !options.is_empty() { write!(f, " {}", display_separated(options, " "))?; } if let Some(position) = column_position { write!(f, " {position}")?; } Ok(()) } AlterTableOperation::RenameConstraint { old_name, new_name } => { write!(f, "RENAME CONSTRAINT {old_name} TO {new_name}") } AlterTableOperation::SwapWith { table_name } => { write!(f, "SWAP WITH {table_name}") } AlterTableOperation::OwnerTo { new_owner } => { write!(f, "OWNER TO {new_owner}") } AlterTableOperation::SetTblProperties { table_properties } => { write!( f, "SET TBLPROPERTIES({})", display_comma_separated(table_properties) ) } AlterTableOperation::FreezePartition { partition, with_name, } => { write!(f, "FREEZE {partition}")?; if let Some(name) = with_name { write!(f, " WITH NAME {name}")?; } Ok(()) } AlterTableOperation::UnfreezePartition { partition, with_name, } => { write!(f, "UNFREEZE {partition}")?; if let Some(name) = with_name { write!(f, " WITH NAME {name}")?; } Ok(()) } AlterTableOperation::ClusterBy { exprs } => { write!(f, "CLUSTER BY ({})", display_comma_separated(exprs))?; Ok(()) } AlterTableOperation::DropClusteringKey => { write!(f, "DROP CLUSTERING KEY")?; Ok(()) } AlterTableOperation::AlterSortKey { columns } => { write!(f, "ALTER SORTKEY({})", display_comma_separated(columns))?; Ok(()) } AlterTableOperation::SuspendRecluster => { write!(f, "SUSPEND RECLUSTER")?; Ok(()) } AlterTableOperation::ResumeRecluster => { write!(f, "RESUME RECLUSTER")?; Ok(()) } AlterTableOperation::Refresh { subpath } => { write!(f, "REFRESH")?; if let Some(path) = subpath { write!(f, " '{path}'")?; } Ok(()) } AlterTableOperation::Suspend => { write!(f, "SUSPEND") } AlterTableOperation::Resume => { write!(f, "RESUME") } AlterTableOperation::AutoIncrement { equals, value } => { write!( f, "AUTO_INCREMENT {}{}", if *equals { "= " } else { "" }, value ) } AlterTableOperation::Lock { equals, lock } => { write!(f, "LOCK {}{}", if *equals { "= " } else { "" }, lock) } AlterTableOperation::ReplicaIdentity { identity } => { write!(f, "REPLICA IDENTITY {identity}") } AlterTableOperation::ValidateConstraint { name } => { write!(f, "VALIDATE CONSTRAINT {name}") } AlterTableOperation::SetOptionsParens { options } => { write!(f, "SET ({})", display_comma_separated(options)) } } } } impl fmt::Display for AlterIndexOperation { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { AlterIndexOperation::RenameIndex { index_name } => { write!(f, "RENAME TO {index_name}") } } } } /// An `ALTER TYPE` statement (`Statement::AlterType`) #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct AlterType { /// Name of the type being altered (may be schema-qualified). pub name: ObjectName, /// The specific alteration operation to perform. pub operation: AlterTypeOperation, } /// An [AlterType] operation #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum AlterTypeOperation { /// Rename the type. Rename(AlterTypeRename), /// Add a new value to the type (for enum-like types). AddValue(AlterTypeAddValue), /// Rename an existing value of the type. RenameValue(AlterTypeRenameValue), } /// See [AlterTypeOperation::Rename] #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct AlterTypeRename { /// The new name for the type. pub new_name: Ident, } /// See [AlterTypeOperation::AddValue] #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct AlterTypeAddValue { /// If true, do not error when the value already exists (`IF NOT EXISTS`). pub if_not_exists: bool, /// The identifier for the new value to add. pub value: Ident, /// Optional relative position for the new value (`BEFORE` / `AFTER`). pub position: Option, } /// See [AlterTypeAddValue] #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum AlterTypeAddValuePosition { /// Place the new value before the given neighbor value. Before(Ident), /// Place the new value after the given neighbor value. After(Ident), } /// See [AlterTypeOperation::RenameValue] #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct AlterTypeRenameValue { /// Existing value identifier to rename. pub from: Ident, /// New identifier for the value. pub to: Ident, } impl fmt::Display for AlterTypeOperation { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { Self::Rename(AlterTypeRename { new_name }) => { write!(f, "RENAME TO {new_name}") } Self::AddValue(AlterTypeAddValue { if_not_exists, value, position, }) => { write!(f, "ADD VALUE")?; if *if_not_exists { write!(f, " IF NOT EXISTS")?; } write!(f, " {value}")?; match position { Some(AlterTypeAddValuePosition::Before(neighbor_value)) => { write!(f, " BEFORE {neighbor_value}")?; } Some(AlterTypeAddValuePosition::After(neighbor_value)) => { write!(f, " AFTER {neighbor_value}")?; } None => {} }; Ok(()) } Self::RenameValue(AlterTypeRenameValue { from, to }) => { write!(f, "RENAME VALUE {from} TO {to}") } } } } /// `ALTER OPERATOR` statement /// See #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct AlterOperator { /// Operator name (can be schema-qualified) pub name: ObjectName, /// Left operand type (`None` if no left operand) pub left_type: Option, /// Right operand type pub right_type: DataType, /// The operation to perform pub operation: AlterOperatorOperation, } /// An [AlterOperator] operation #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum AlterOperatorOperation { /// `OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }` OwnerTo(Owner), /// `SET SCHEMA new_schema` /// Set the operator's schema name. SetSchema { /// New schema name for the operator schema_name: ObjectName, }, /// `SET ( options )` Set { /// List of operator options to set options: Vec, }, } /// Option for `ALTER OPERATOR SET` operation #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum OperatorOption { /// `RESTRICT = { res_proc | NONE }` Restrict(Option), /// `JOIN = { join_proc | NONE }` Join(Option), /// `COMMUTATOR = com_op` Commutator(ObjectName), /// `NEGATOR = neg_op` Negator(ObjectName), /// `HASHES` Hashes, /// `MERGES` Merges, } impl fmt::Display for AlterOperator { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "ALTER OPERATOR {} (", self.name)?; if let Some(left_type) = &self.left_type { write!(f, "{}", left_type)?; } else { write!(f, "NONE")?; } write!(f, ", {}) {}", self.right_type, self.operation) } } impl fmt::Display for AlterOperatorOperation { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { Self::OwnerTo(owner) => write!(f, "OWNER TO {}", owner), Self::SetSchema { schema_name } => write!(f, "SET SCHEMA {}", schema_name), Self::Set { options } => { write!(f, "SET (")?; for (i, option) in options.iter().enumerate() { if i > 0 { write!(f, ", ")?; } write!(f, "{}", option)?; } write!(f, ")") } } } } impl fmt::Display for OperatorOption { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { Self::Restrict(Some(proc_name)) => write!(f, "RESTRICT = {}", proc_name), Self::Restrict(None) => write!(f, "RESTRICT = NONE"), Self::Join(Some(proc_name)) => write!(f, "JOIN = {}", proc_name), Self::Join(None) => write!(f, "JOIN = NONE"), Self::Commutator(op_name) => write!(f, "COMMUTATOR = {}", op_name), Self::Negator(op_name) => write!(f, "NEGATOR = {}", op_name), Self::Hashes => write!(f, "HASHES"), Self::Merges => write!(f, "MERGES"), } } } /// An `ALTER COLUMN` (`Statement::AlterTable`) operation #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum AlterColumnOperation { /// `SET NOT NULL` SetNotNull, /// `DROP NOT NULL` DropNotNull, /// `SET DEFAULT ` /// Set the column default value. SetDefault { /// Expression representing the new default value. value: Expr, }, /// `DROP DEFAULT` DropDefault, /// `[SET DATA] TYPE [USING ]` SetDataType { /// Target data type for the column. data_type: DataType, /// PostgreSQL-specific `USING ` expression for conversion. using: Option, /// Set to true if the statement includes the `SET DATA TYPE` keywords. had_set: bool, }, /// `ADD GENERATED { ALWAYS | BY DEFAULT } AS IDENTITY [ ( sequence_options ) ]` /// /// Note: this is a PostgreSQL-specific operation. AddGenerated { /// Optional `GENERATED AS` specifier (e.g. `ALWAYS` or `BY DEFAULT`). generated_as: Option, /// Optional sequence options for identity generation. sequence_options: Option>, }, } impl fmt::Display for AlterColumnOperation { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { AlterColumnOperation::SetNotNull => write!(f, "SET NOT NULL",), AlterColumnOperation::DropNotNull => write!(f, "DROP NOT NULL",), AlterColumnOperation::SetDefault { value } => { write!(f, "SET DEFAULT {value}") } AlterColumnOperation::DropDefault => { write!(f, "DROP DEFAULT") } AlterColumnOperation::SetDataType { data_type, using, had_set, } => { if *had_set { write!(f, "SET DATA ")?; } write!(f, "TYPE {data_type}")?; if let Some(expr) = using { write!(f, " USING {expr}")?; } Ok(()) } AlterColumnOperation::AddGenerated { generated_as, sequence_options, } => { let generated_as = match generated_as { Some(GeneratedAs::Always) => " ALWAYS", Some(GeneratedAs::ByDefault) => " BY DEFAULT", _ => "", }; write!(f, "ADD GENERATED{generated_as} AS IDENTITY",)?; if let Some(options) = sequence_options { write!(f, " (")?; for sequence_option in options { write!(f, "{sequence_option}")?; } write!(f, " )")?; } Ok(()) } } } } /// Representation whether a definition can can contains the KEY or INDEX keywords with the same /// meaning. /// /// This enum initially is directed to `FULLTEXT`,`SPATIAL`, and `UNIQUE` indexes on create table /// statements of `MySQL` [(1)]. /// /// [1]: https://dev.mysql.com/doc/refman/8.0/en/create-table.html #[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 KeyOrIndexDisplay { /// Nothing to display None, /// Display the KEY keyword Key, /// Display the INDEX keyword Index, } impl KeyOrIndexDisplay { /// Check if this is the `None` variant. pub fn is_none(self) -> bool { matches!(self, Self::None) } } impl fmt::Display for KeyOrIndexDisplay { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let left_space = matches!(f.align(), Some(fmt::Alignment::Right)); if left_space && !self.is_none() { f.write_char(' ')? } match self { KeyOrIndexDisplay::None => { write!(f, "") } KeyOrIndexDisplay::Key => { write!(f, "KEY") } KeyOrIndexDisplay::Index => { write!(f, "INDEX") } } } } /// Indexing method used by that index. /// /// This structure isn't present on ANSI, but is found at least in [`MySQL` CREATE TABLE][1], /// [`MySQL` CREATE INDEX][2], and [Postgresql CREATE INDEX][3] statements. /// /// [1]: https://dev.mysql.com/doc/refman/8.0/en/create-table.html /// [2]: https://dev.mysql.com/doc/refman/8.0/en/create-index.html /// [3]: https://www.postgresql.org/docs/14/sql-createindex.html #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum IndexType { /// B-Tree index (commonly default for many databases). BTree, /// Hash index. Hash, /// Generalized Inverted Index (GIN). GIN, /// Generalized Search Tree (GiST) index. GiST, /// Space-partitioned GiST (SPGiST) index. SPGiST, /// Block Range Index (BRIN). BRIN, /// Bloom filter based index. Bloom, /// Users may define their own index types, which would /// not be covered by the above variants. Custom(Ident), } impl fmt::Display for IndexType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { Self::BTree => write!(f, "BTREE"), Self::Hash => write!(f, "HASH"), Self::GIN => write!(f, "GIN"), Self::GiST => write!(f, "GIST"), Self::SPGiST => write!(f, "SPGIST"), Self::BRIN => write!(f, "BRIN"), Self::Bloom => write!(f, "BLOOM"), Self::Custom(name) => write!(f, "{name}"), } } } /// MySQL index option, used in [`CREATE TABLE`], [`CREATE INDEX`], and [`ALTER TABLE`]. /// /// [`CREATE TABLE`]: https://dev.mysql.com/doc/refman/8.4/en/create-table.html /// [`CREATE INDEX`]: https://dev.mysql.com/doc/refman/8.4/en/create-index.html /// [`ALTER TABLE`]: https://dev.mysql.com/doc/refman/8.4/en/alter-table.html #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum IndexOption { /// `USING { BTREE | HASH }`: Index type to use for the index. /// /// Note that we permissively parse non-MySQL index types, like `GIN`. Using(IndexType), /// `COMMENT 'string'`: Specifies a comment for the index. Comment(String), } impl fmt::Display for IndexOption { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { Self::Using(index_type) => write!(f, "USING {index_type}"), Self::Comment(s) => write!(f, "COMMENT '{s}'"), } } } /// [PostgreSQL] unique index nulls handling option: `[ NULLS [ NOT ] DISTINCT ]` /// /// [PostgreSQL]: https://www.postgresql.org/docs/17/sql-altertable.html #[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum NullsDistinctOption { /// Not specified None, /// NULLS DISTINCT Distinct, /// NULLS NOT DISTINCT NotDistinct, } impl fmt::Display for NullsDistinctOption { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { Self::None => Ok(()), Self::Distinct => write!(f, " NULLS DISTINCT"), Self::NotDistinct => write!(f, " NULLS NOT DISTINCT"), } } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// A parameter of a stored procedure or function declaration. pub struct ProcedureParam { /// Parameter name. pub name: Ident, /// Parameter data type. pub data_type: DataType, /// Optional mode (`IN`, `OUT`, `INOUT`, etc.). pub mode: Option, /// Optional default expression for the parameter. pub default: Option, } impl fmt::Display for ProcedureParam { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { if let Some(mode) = &self.mode { if let Some(default) = &self.default { write!(f, "{mode} {} {} = {}", self.name, self.data_type, default) } else { write!(f, "{mode} {} {}", self.name, self.data_type) } } else if let Some(default) = &self.default { write!(f, "{} {} = {}", self.name, self.data_type, default) } else { write!(f, "{} {}", self.name, self.data_type) } } } /// SQL column definition #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct ColumnDef { /// Column name. pub name: Ident, /// Column data type. pub data_type: DataType, /// Column options (defaults, constraints, generated, etc.). pub options: Vec, } impl fmt::Display for ColumnDef { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { if self.data_type == DataType::Unspecified { write!(f, "{}", self.name)?; } else { write!(f, "{} {}", self.name, self.data_type)?; } for option in &self.options { write!(f, " {option}")?; } Ok(()) } } /// Column definition specified in a `CREATE VIEW` statement. /// /// Syntax /// ```markdown /// [data_type][OPTIONS(option, ...)] /// /// option: = /// ``` /// /// Examples: /// ```sql /// name /// age OPTIONS(description = "age column", tag = "prod") /// amount COMMENT 'The total amount for the order line' /// created_at DateTime64 /// ``` #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct ViewColumnDef { /// Column identifier. pub name: Ident, /// Optional data type for the column. pub data_type: Option, /// Optional column options (defaults, comments, etc.). pub options: Option, } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Representation of how multiple `ColumnOption`s are grouped for a column. pub enum ColumnOptions { /// Options separated by comma: `OPTIONS(a, b, c)`. CommaSeparated(Vec), /// Options separated by spaces: `OPTION_A OPTION_B`. SpaceSeparated(Vec), } impl ColumnOptions { /// Get the column options as a slice. pub fn as_slice(&self) -> &[ColumnOption] { match self { ColumnOptions::CommaSeparated(options) => options.as_slice(), ColumnOptions::SpaceSeparated(options) => options.as_slice(), } } } impl fmt::Display for ViewColumnDef { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{}", self.name)?; if let Some(data_type) = self.data_type.as_ref() { write!(f, " {data_type}")?; } if let Some(options) = self.options.as_ref() { match options { ColumnOptions::CommaSeparated(column_options) => { write!(f, " {}", display_comma_separated(column_options.as_slice()))?; } ColumnOptions::SpaceSeparated(column_options) => { write!(f, " {}", display_separated(column_options.as_slice(), " "))? } } } Ok(()) } } /// An optionally-named `ColumnOption`: `[ CONSTRAINT ] `. /// /// Note that implementations are substantially more permissive than the ANSI /// specification on what order column options can be presented in, and whether /// they are allowed to be named. The specification distinguishes between /// constraints (NOT NULL, UNIQUE, PRIMARY KEY, and CHECK), which can be named /// and can appear in any order, and other options (DEFAULT, GENERATED), which /// cannot be named and must appear in a fixed order. `PostgreSQL`, however, /// allows preceding any option with `CONSTRAINT `, even those that are /// not really constraints, like NULL and DEFAULT. MSSQL is less permissive, /// allowing DEFAULT, UNIQUE, PRIMARY KEY and CHECK to be named, but not NULL or /// NOT NULL constraints (the last of which is in violation of the spec). /// /// For maximum flexibility, we don't distinguish between constraint and /// non-constraint options, lumping them all together under the umbrella of /// "column options," and we allow any column option to be named. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct ColumnOptionDef { /// Optional name of the constraint. pub name: Option, /// The actual column option (e.g. `NOT NULL`, `DEFAULT`, `GENERATED`, ...). pub option: ColumnOption, } impl fmt::Display for ColumnOptionDef { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{}{}", display_constraint_name(&self.name), self.option) } } /// Identity is a column option for defining an identity or autoincrement column in a `CREATE TABLE` statement. /// Syntax /// ```sql /// { IDENTITY | AUTOINCREMENT } [ (seed , increment) | START num INCREMENT num ] [ ORDER | NOORDER ] /// ``` /// [MS SQL Server]: https://learn.microsoft.com/en-us/sql/t-sql/statements/create-table-transact-sql-identity-property /// [Snowflake]: https://docs.snowflake.com/en/sql-reference/sql/create-table #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum IdentityPropertyKind { /// An identity property declared via the `AUTOINCREMENT` key word /// Example: /// ```sql /// AUTOINCREMENT(100, 1) NOORDER /// AUTOINCREMENT START 100 INCREMENT 1 ORDER /// ``` /// [Snowflake]: https://docs.snowflake.com/en/sql-reference/sql/create-table Autoincrement(IdentityProperty), /// An identity property declared via the `IDENTITY` key word /// Example, [MS SQL Server] or [Snowflake]: /// ```sql /// IDENTITY(100, 1) /// ``` /// [Snowflake] /// ```sql /// IDENTITY(100, 1) ORDER /// IDENTITY START 100 INCREMENT 1 NOORDER /// ``` /// [MS SQL Server]: https://learn.microsoft.com/en-us/sql/t-sql/statements/create-table-transact-sql-identity-property /// [Snowflake]: https://docs.snowflake.com/en/sql-reference/sql/create-table Identity(IdentityProperty), } impl fmt::Display for IdentityPropertyKind { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let (command, property) = match self { IdentityPropertyKind::Identity(property) => ("IDENTITY", property), IdentityPropertyKind::Autoincrement(property) => ("AUTOINCREMENT", property), }; write!(f, "{command}")?; if let Some(parameters) = &property.parameters { write!(f, "{parameters}")?; } if let Some(order) = &property.order { write!(f, "{order}")?; } Ok(()) } } /// Properties for the `IDENTITY` / `AUTOINCREMENT` column option. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct IdentityProperty { /// Optional parameters specifying seed/increment for the identity column. pub parameters: Option, /// Optional ordering specifier (`ORDER` / `NOORDER`). pub order: Option, } /// A format of parameters of identity column. /// /// It is [Snowflake] specific. /// Syntax /// ```sql /// (seed , increment) | START num INCREMENT num /// ``` /// [MS SQL Server] uses one way of representing these parameters. /// Syntax /// ```sql /// (seed , increment) /// ``` /// [MS SQL Server]: https://learn.microsoft.com/en-us/sql/t-sql/statements/create-table-transact-sql-identity-property /// [Snowflake]: https://docs.snowflake.com/en/sql-reference/sql/create-table #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum IdentityPropertyFormatKind { /// A parameters of identity column declared like parameters of function call /// Example: /// ```sql /// (100, 1) /// ``` /// [MS SQL Server]: https://learn.microsoft.com/en-us/sql/t-sql/statements/create-table-transact-sql-identity-property /// [Snowflake]: https://docs.snowflake.com/en/sql-reference/sql/create-table FunctionCall(IdentityParameters), /// A parameters of identity column declared with keywords `START` and `INCREMENT` /// Example: /// ```sql /// START 100 INCREMENT 1 /// ``` /// [Snowflake]: https://docs.snowflake.com/en/sql-reference/sql/create-table StartAndIncrement(IdentityParameters), } impl fmt::Display for IdentityPropertyFormatKind { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { IdentityPropertyFormatKind::FunctionCall(parameters) => { write!(f, "({}, {})", parameters.seed, parameters.increment) } IdentityPropertyFormatKind::StartAndIncrement(parameters) => { write!( f, " START {} INCREMENT {}", parameters.seed, parameters.increment ) } } } } /// Parameters specifying seed and increment for identity columns. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct IdentityParameters { /// The initial seed expression for the identity column. pub seed: Expr, /// The increment expression for the identity column. pub increment: Expr, } /// The identity column option specifies how values are generated for the auto-incremented column, either in increasing or decreasing order. /// Syntax /// ```sql /// ORDER | NOORDER /// ``` /// [Snowflake]: https://docs.snowflake.com/en/sql-reference/sql/create-table #[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum IdentityPropertyOrder { /// `ORDER` - preserve ordering for generated values (where supported). Order, /// `NOORDER` - do not enforce ordering for generated values. NoOrder, } impl fmt::Display for IdentityPropertyOrder { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { IdentityPropertyOrder::Order => write!(f, " ORDER"), IdentityPropertyOrder::NoOrder => write!(f, " NOORDER"), } } } /// Column policy that identify a security policy of access to a column. /// Syntax /// ```sql /// [ WITH ] MASKING POLICY [ USING ( , , ... ) ] /// [ WITH ] PROJECTION POLICY /// ``` /// [Snowflake]: https://docs.snowflake.com/en/sql-reference/sql/create-table #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum ColumnPolicy { /// `MASKING POLICY ()` MaskingPolicy(ColumnPolicyProperty), /// `PROJECTION POLICY ()` ProjectionPolicy(ColumnPolicyProperty), } impl fmt::Display for ColumnPolicy { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let (command, property) = match self { ColumnPolicy::MaskingPolicy(property) => ("MASKING POLICY", property), ColumnPolicy::ProjectionPolicy(property) => ("PROJECTION POLICY", property), }; if property.with { write!(f, "WITH ")?; } write!(f, "{command} {}", property.policy_name)?; if let Some(using_columns) = &property.using_columns { write!(f, " USING ({})", display_comma_separated(using_columns))?; } Ok(()) } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Properties describing a column policy (masking or projection). pub struct ColumnPolicyProperty { /// This flag indicates that the column policy option is declared using the `WITH` prefix. /// Example /// ```sql /// WITH PROJECTION POLICY sample_policy /// ``` /// [Snowflake]: https://docs.snowflake.com/en/sql-reference/sql/create-table pub with: bool, /// The name of the policy to apply to the column. pub policy_name: ObjectName, /// Optional list of column identifiers referenced by the policy. pub using_columns: Option>, } /// Tags option of column /// Syntax /// ```sql /// [ WITH ] TAG ( = '' [ , = '' , ... ] ) /// ``` /// [Snowflake]: https://docs.snowflake.com/en/sql-reference/sql/create-table #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct TagsColumnOption { /// This flag indicates that the tags option is declared using the `WITH` prefix. /// Example: /// ```sql /// WITH TAG (A = 'Tag A') /// ``` /// [Snowflake]: https://docs.snowflake.com/en/sql-reference/sql/create-table pub with: bool, /// List of tags to attach to the column. pub tags: Vec, } impl fmt::Display for TagsColumnOption { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { if self.with { write!(f, "WITH ")?; } write!(f, "TAG ({})", display_comma_separated(&self.tags))?; Ok(()) } } /// `ColumnOption`s are modifiers that follow a column definition in a `CREATE /// TABLE` statement. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum ColumnOption { /// `NULL` Null, /// `NOT NULL` NotNull, /// `DEFAULT ` Default(Expr), /// `MATERIALIZE ` /// Syntax: `b INT MATERIALIZE (a + 1)` /// /// [ClickHouse](https://clickhouse.com/docs/en/sql-reference/statements/create/table#default_values) Materialized(Expr), /// `EPHEMERAL []` /// /// [ClickHouse](https://clickhouse.com/docs/en/sql-reference/statements/create/table#default_values) Ephemeral(Option), /// `ALIAS ` /// /// [ClickHouse](https://clickhouse.com/docs/en/sql-reference/statements/create/table#default_values) Alias(Expr), /// `PRIMARY KEY []` PrimaryKey(PrimaryKeyConstraint), /// `UNIQUE []` Unique(UniqueConstraint), /// A referential integrity constraint (`REFERENCES () /// [ MATCH { FULL | PARTIAL | SIMPLE } ] /// { [ON DELETE ] [ON UPDATE ] | /// [ON UPDATE ] [ON DELETE ] /// } /// [] /// `). ForeignKey(ForeignKeyConstraint), /// `CHECK ()` Check(CheckConstraint), /// Dialect-specific options, such as: /// - MySQL's `AUTO_INCREMENT` or SQLite's `AUTOINCREMENT` /// - ... DialectSpecific(Vec), /// `CHARACTER SET ` column option CharacterSet(ObjectName), /// `COLLATE ` column option Collation(ObjectName), /// `COMMENT ''` column option Comment(String), /// `ON UPDATE ` column option OnUpdate(Expr), /// `Generated`s are modifiers that follow a column definition in a `CREATE /// TABLE` statement. Generated { /// How the column is generated (e.g. `GENERATED ALWAYS`, `BY DEFAULT`, or expression-stored). generated_as: GeneratedAs, /// Sequence/identity options when generation is backed by a sequence. sequence_options: Option>, /// Optional expression used to generate the column value. generation_expr: Option, /// Mode of the generated expression (`VIRTUAL` or `STORED`) when `generation_expr` is present. generation_expr_mode: Option, /// false if 'GENERATED ALWAYS' is skipped (option starts with AS) generated_keyword: bool, }, /// BigQuery specific: Explicit column options in a view [1] or table [2] /// Syntax /// ```sql /// OPTIONS(description="field desc") /// ``` /// [1]: https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language#view_column_option_list /// [2]: https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language#column_option_list Options(Vec), /// Creates an identity or an autoincrement column in a table. /// Syntax /// ```sql /// { IDENTITY | AUTOINCREMENT } [ (seed , increment) | START num INCREMENT num ] [ ORDER | NOORDER ] /// ``` /// [MS SQL Server]: https://learn.microsoft.com/en-us/sql/t-sql/statements/create-table-transact-sql-identity-property /// [Snowflake]: https://docs.snowflake.com/en/sql-reference/sql/create-table Identity(IdentityPropertyKind), /// SQLite specific: ON CONFLICT option on column definition /// OnConflict(Keyword), /// Snowflake specific: an option of specifying security masking or projection policy to set on a column. /// Syntax: /// ```sql /// [ WITH ] MASKING POLICY [ USING ( , , ... ) ] /// [ WITH ] PROJECTION POLICY /// ``` /// [Snowflake]: https://docs.snowflake.com/en/sql-reference/sql/create-table Policy(ColumnPolicy), /// Snowflake specific: Specifies the tag name and the tag string value. /// Syntax: /// ```sql /// [ WITH ] TAG ( = '' [ , = '' , ... ] ) /// ``` /// [Snowflake]: https://docs.snowflake.com/en/sql-reference/sql/create-table Tags(TagsColumnOption), /// MySQL specific: Spatial reference identifier /// Syntax: /// ```sql /// CREATE TABLE geom (g GEOMETRY NOT NULL SRID 4326); /// ``` /// [MySQL]: https://dev.mysql.com/doc/refman/8.4/en/creating-spatial-indexes.html Srid(Box), /// MySQL specific: Column is invisible via SELECT * /// Syntax: /// ```sql /// CREATE TABLE t (foo INT, bar INT INVISIBLE); /// ``` /// [MySQL]: https://dev.mysql.com/doc/refman/8.4/en/invisible-columns.html Invisible, } impl From for ColumnOption { fn from(c: UniqueConstraint) -> Self { ColumnOption::Unique(c) } } impl From for ColumnOption { fn from(c: PrimaryKeyConstraint) -> Self { ColumnOption::PrimaryKey(c) } } impl From for ColumnOption { fn from(c: CheckConstraint) -> Self { ColumnOption::Check(c) } } impl From for ColumnOption { fn from(fk: ForeignKeyConstraint) -> Self { ColumnOption::ForeignKey(fk) } } impl fmt::Display for ColumnOption { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { use ColumnOption::*; match self { Null => write!(f, "NULL"), NotNull => write!(f, "NOT NULL"), Default(expr) => write!(f, "DEFAULT {expr}"), Materialized(expr) => write!(f, "MATERIALIZED {expr}"), Ephemeral(expr) => { if let Some(e) = expr { write!(f, "EPHEMERAL {e}") } else { write!(f, "EPHEMERAL") } } Alias(expr) => write!(f, "ALIAS {expr}"), PrimaryKey(constraint) => { write!(f, "PRIMARY KEY")?; if let Some(characteristics) = &constraint.characteristics { write!(f, " {characteristics}")?; } Ok(()) } Unique(constraint) => { write!(f, "UNIQUE{:>}", constraint.index_type_display)?; if let Some(characteristics) = &constraint.characteristics { write!(f, " {characteristics}")?; } Ok(()) } ForeignKey(constraint) => { write!(f, "REFERENCES {}", constraint.foreign_table)?; if !constraint.referred_columns.is_empty() { write!( f, " ({})", display_comma_separated(&constraint.referred_columns) )?; } if let Some(match_kind) = &constraint.match_kind { write!(f, " {match_kind}")?; } if let Some(action) = &constraint.on_delete { write!(f, " ON DELETE {action}")?; } if let Some(action) = &constraint.on_update { write!(f, " ON UPDATE {action}")?; } if let Some(characteristics) = &constraint.characteristics { write!(f, " {characteristics}")?; } Ok(()) } Check(constraint) => write!(f, "{constraint}"), DialectSpecific(val) => write!(f, "{}", display_separated(val, " ")), CharacterSet(n) => write!(f, "CHARACTER SET {n}"), Collation(n) => write!(f, "COLLATE {n}"), Comment(v) => write!(f, "COMMENT '{}'", escape_single_quote_string(v)), OnUpdate(expr) => write!(f, "ON UPDATE {expr}"), Generated { generated_as, sequence_options, generation_expr, generation_expr_mode, generated_keyword, } => { if let Some(expr) = generation_expr { let modifier = match generation_expr_mode { None => "", Some(GeneratedExpressionMode::Virtual) => " VIRTUAL", Some(GeneratedExpressionMode::Stored) => " STORED", }; if *generated_keyword { write!(f, "GENERATED ALWAYS AS ({expr}){modifier}")?; } else { write!(f, "AS ({expr}){modifier}")?; } Ok(()) } else { // Like Postgres - generated from sequence let when = match generated_as { GeneratedAs::Always => "ALWAYS", GeneratedAs::ByDefault => "BY DEFAULT", // ExpStored goes with an expression, handled above GeneratedAs::ExpStored => "", }; write!(f, "GENERATED {when} AS IDENTITY")?; if sequence_options.is_some() { let so = sequence_options.as_ref().unwrap(); if !so.is_empty() { write!(f, " (")?; } for sequence_option in so { write!(f, "{sequence_option}")?; } if !so.is_empty() { write!(f, " )")?; } } Ok(()) } } Options(options) => { write!(f, "OPTIONS({})", display_comma_separated(options)) } Identity(parameters) => { write!(f, "{parameters}") } OnConflict(keyword) => { write!(f, "ON CONFLICT {keyword:?}")?; Ok(()) } Policy(parameters) => { write!(f, "{parameters}") } Tags(tags) => { write!(f, "{tags}") } Srid(srid) => { write!(f, "SRID {srid}") } Invisible => { write!(f, "INVISIBLE") } } } } /// `GeneratedAs`s are modifiers that follow a column option in a `generated`. /// 'ExpStored' is used for a column generated from an expression and stored. #[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum GeneratedAs { /// `GENERATED ALWAYS` Always, /// `GENERATED BY DEFAULT` ByDefault, /// Expression-based generated column that is stored (used internally for expression-stored columns) ExpStored, } /// `GeneratedExpressionMode`s are modifiers that follow an expression in a `generated`. /// No modifier is typically the same as Virtual. #[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum GeneratedExpressionMode { /// `VIRTUAL` generated expression Virtual, /// `STORED` generated expression Stored, } #[must_use] pub(crate) fn display_constraint_name(name: &'_ Option) -> impl fmt::Display + '_ { struct ConstraintName<'a>(&'a Option); impl fmt::Display for ConstraintName<'_> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { if let Some(name) = self.0 { write!(f, "CONSTRAINT {name} ")?; } Ok(()) } } ConstraintName(name) } /// If `option` is /// * `Some(inner)` => create display struct for `"{prefix}{inner}{postfix}"` /// * `_` => do nothing #[must_use] pub(crate) fn display_option<'a, T: fmt::Display>( prefix: &'a str, postfix: &'a str, option: &'a Option, ) -> impl fmt::Display + 'a { struct OptionDisplay<'a, T>(&'a str, &'a str, &'a Option); impl fmt::Display for OptionDisplay<'_, T> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { if let Some(inner) = self.2 { let (prefix, postfix) = (self.0, self.1); write!(f, "{prefix}{inner}{postfix}")?; } Ok(()) } } OptionDisplay(prefix, postfix, option) } /// If `option` is /// * `Some(inner)` => create display struct for `" {inner}"` /// * `_` => do nothing #[must_use] pub(crate) fn display_option_spaced(option: &Option) -> impl fmt::Display + '_ { display_option(" ", "", option) } /// ` = [ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ] [ ENFORCED | NOT ENFORCED ]` /// /// Used in UNIQUE and foreign key constraints. The individual settings may occur in any order. #[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Default, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct ConstraintCharacteristics { /// `[ DEFERRABLE | NOT DEFERRABLE ]` pub deferrable: Option, /// `[ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]` pub initially: Option, /// `[ ENFORCED | NOT ENFORCED ]` pub enforced: Option, } /// Initial setting for deferrable constraints (`INITIALLY IMMEDIATE` or `INITIALLY DEFERRED`). #[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 DeferrableInitial { /// `INITIALLY IMMEDIATE` Immediate, /// `INITIALLY DEFERRED` Deferred, } impl ConstraintCharacteristics { fn deferrable_text(&self) -> Option<&'static str> { self.deferrable.map(|deferrable| { if deferrable { "DEFERRABLE" } else { "NOT DEFERRABLE" } }) } fn initially_immediate_text(&self) -> Option<&'static str> { self.initially .map(|initially_immediate| match initially_immediate { DeferrableInitial::Immediate => "INITIALLY IMMEDIATE", DeferrableInitial::Deferred => "INITIALLY DEFERRED", }) } fn enforced_text(&self) -> Option<&'static str> { self.enforced.map( |enforced| { if enforced { "ENFORCED" } else { "NOT ENFORCED" } }, ) } } impl fmt::Display for ConstraintCharacteristics { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let deferrable = self.deferrable_text(); let initially_immediate = self.initially_immediate_text(); let enforced = self.enforced_text(); match (deferrable, initially_immediate, enforced) { (None, None, None) => Ok(()), (None, None, Some(enforced)) => write!(f, "{enforced}"), (None, Some(initial), None) => write!(f, "{initial}"), (None, Some(initial), Some(enforced)) => write!(f, "{initial} {enforced}"), (Some(deferrable), None, None) => write!(f, "{deferrable}"), (Some(deferrable), None, Some(enforced)) => write!(f, "{deferrable} {enforced}"), (Some(deferrable), Some(initial), None) => write!(f, "{deferrable} {initial}"), (Some(deferrable), Some(initial), Some(enforced)) => { write!(f, "{deferrable} {initial} {enforced}") } } } } /// ` = /// { RESTRICT | CASCADE | SET NULL | NO ACTION | SET DEFAULT }` /// /// Used in foreign key constraints in `ON UPDATE` and `ON DELETE` options. #[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 ReferentialAction { /// `RESTRICT` - disallow action if it would break referential integrity. Restrict, /// `CASCADE` - propagate the action to referencing rows. Cascade, /// `SET NULL` - set referencing columns to NULL. SetNull, /// `NO ACTION` - no action at the time; may be deferred. NoAction, /// `SET DEFAULT` - set referencing columns to their default values. SetDefault, } impl fmt::Display for ReferentialAction { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str(match self { ReferentialAction::Restrict => "RESTRICT", ReferentialAction::Cascade => "CASCADE", ReferentialAction::SetNull => "SET NULL", ReferentialAction::NoAction => "NO ACTION", ReferentialAction::SetDefault => "SET DEFAULT", }) } } /// ` ::= CASCADE | RESTRICT`. /// /// Used in `DROP` statements. #[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 DropBehavior { /// `RESTRICT` - refuse to drop if there are any dependent objects. Restrict, /// `CASCADE` - automatically drop objects that depend on the object being dropped. Cascade, } impl fmt::Display for DropBehavior { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str(match self { DropBehavior::Restrict => "RESTRICT", DropBehavior::Cascade => "CASCADE", }) } } /// SQL user defined type definition #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum UserDefinedTypeRepresentation { /// Composite type: `CREATE TYPE name AS (attributes)` Composite { /// List of attributes for the composite type. attributes: Vec, }, /// Enum type: `CREATE TYPE name AS ENUM (labels)` /// /// Note: this is PostgreSQL-specific. See /// Enum type: `CREATE TYPE name AS ENUM (labels)` Enum { /// Labels that make up the enum type. labels: Vec, }, /// Range type: `CREATE TYPE name AS RANGE (options)` /// /// Note: this is PostgreSQL-specific. See Range { /// Options for the range type definition. options: Vec, }, /// Base type (SQL definition): `CREATE TYPE name (options)` /// /// Note the lack of `AS` keyword /// /// Note: this is PostgreSQL-specific. See SqlDefinition { /// Options for SQL definition of the user-defined type. options: Vec, }, } impl fmt::Display for UserDefinedTypeRepresentation { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { Self::Composite { attributes } => { write!(f, "AS ({})", display_comma_separated(attributes)) } Self::Enum { labels } => { write!(f, "AS ENUM ({})", display_comma_separated(labels)) } Self::Range { options } => { write!(f, "AS RANGE ({})", display_comma_separated(options)) } Self::SqlDefinition { options } => { write!(f, "({})", display_comma_separated(options)) } } } } /// SQL user defined type attribute definition #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct UserDefinedTypeCompositeAttributeDef { /// Attribute name. pub name: Ident, /// Attribute data type. pub data_type: DataType, /// Optional collation for the attribute. pub collation: Option, } impl fmt::Display for UserDefinedTypeCompositeAttributeDef { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{} {}", self.name, self.data_type)?; if let Some(collation) = &self.collation { write!(f, " COLLATE {collation}")?; } Ok(()) } } /// Internal length specification for PostgreSQL user-defined base types. /// /// Specifies the internal length in bytes of the new type's internal representation. /// The default assumption is that it is variable-length. /// /// # PostgreSQL Documentation /// See: /// /// # Examples /// ```sql /// CREATE TYPE mytype ( /// INPUT = in_func, /// OUTPUT = out_func, /// INTERNALLENGTH = 16 -- Fixed 16-byte length /// ); /// /// CREATE TYPE mytype2 ( /// INPUT = in_func, /// OUTPUT = out_func, /// INTERNALLENGTH = VARIABLE -- Variable length /// ); /// ``` #[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 UserDefinedTypeInternalLength { /// Fixed internal length: `INTERNALLENGTH = ` Fixed(u64), /// Variable internal length: `INTERNALLENGTH = VARIABLE` Variable, } impl fmt::Display for UserDefinedTypeInternalLength { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { UserDefinedTypeInternalLength::Fixed(n) => write!(f, "{}", n), UserDefinedTypeInternalLength::Variable => write!(f, "VARIABLE"), } } } /// Alignment specification for PostgreSQL user-defined base types. /// /// Specifies the storage alignment requirement for values of the data type. /// The allowed values equate to alignment on 1, 2, 4, or 8 byte boundaries. /// Note that variable-length types must have an alignment of at least 4, since /// they necessarily contain an int4 as their first component. /// /// # PostgreSQL Documentation /// See: /// /// # Examples /// ```sql /// CREATE TYPE mytype ( /// INPUT = in_func, /// OUTPUT = out_func, /// ALIGNMENT = int4 -- 4-byte alignment /// ); /// ``` #[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 Alignment { /// Single-byte alignment: `ALIGNMENT = char` Char, /// 2-byte alignment: `ALIGNMENT = int2` Int2, /// 4-byte alignment: `ALIGNMENT = int4` Int4, /// 8-byte alignment: `ALIGNMENT = double` Double, } impl fmt::Display for Alignment { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { Alignment::Char => write!(f, "char"), Alignment::Int2 => write!(f, "int2"), Alignment::Int4 => write!(f, "int4"), Alignment::Double => write!(f, "double"), } } } /// Storage specification for PostgreSQL user-defined base types. /// /// Specifies the storage strategy for values of the data type: /// - `plain`: Prevents compression and out-of-line storage (for fixed-length types) /// - `external`: Allows out-of-line storage but not compression /// - `extended`: Allows both compression and out-of-line storage (default for most types) /// - `main`: Allows compression but discourages out-of-line storage /// /// # PostgreSQL Documentation /// See: /// /// # Examples /// ```sql /// CREATE TYPE mytype ( /// INPUT = in_func, /// OUTPUT = out_func, /// STORAGE = plain /// ); /// ``` #[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 UserDefinedTypeStorage { /// No compression or out-of-line storage: `STORAGE = plain` Plain, /// Out-of-line storage allowed, no compression: `STORAGE = external` External, /// Both compression and out-of-line storage allowed: `STORAGE = extended` Extended, /// Compression allowed, out-of-line discouraged: `STORAGE = main` Main, } impl fmt::Display for UserDefinedTypeStorage { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { UserDefinedTypeStorage::Plain => write!(f, "plain"), UserDefinedTypeStorage::External => write!(f, "external"), UserDefinedTypeStorage::Extended => write!(f, "extended"), UserDefinedTypeStorage::Main => write!(f, "main"), } } } /// Options for PostgreSQL `CREATE TYPE ... AS RANGE` statement. /// /// Range types are data types representing a range of values of some element type /// (called the range's subtype). These options configure the behavior of the range type. /// /// # PostgreSQL Documentation /// See: /// /// # Examples /// ```sql /// CREATE TYPE int4range AS RANGE ( /// SUBTYPE = int4, /// SUBTYPE_OPCLASS = int4_ops, /// CANONICAL = int4range_canonical, /// SUBTYPE_DIFF = int4range_subdiff /// ); /// ``` #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum UserDefinedTypeRangeOption { /// The element type that the range type will represent: `SUBTYPE = subtype` Subtype(DataType), /// The operator class for the subtype: `SUBTYPE_OPCLASS = subtype_operator_class` SubtypeOpClass(ObjectName), /// Collation to use for ordering the subtype: `COLLATION = collation` Collation(ObjectName), /// Function to convert range values to canonical form: `CANONICAL = canonical_function` Canonical(ObjectName), /// Function to compute the difference between two subtype values: `SUBTYPE_DIFF = subtype_diff_function` SubtypeDiff(ObjectName), /// Name of the corresponding multirange type: `MULTIRANGE_TYPE_NAME = multirange_type_name` MultirangeTypeName(ObjectName), } impl fmt::Display for UserDefinedTypeRangeOption { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { UserDefinedTypeRangeOption::Subtype(dt) => write!(f, "SUBTYPE = {}", dt), UserDefinedTypeRangeOption::SubtypeOpClass(name) => { write!(f, "SUBTYPE_OPCLASS = {}", name) } UserDefinedTypeRangeOption::Collation(name) => write!(f, "COLLATION = {}", name), UserDefinedTypeRangeOption::Canonical(name) => write!(f, "CANONICAL = {}", name), UserDefinedTypeRangeOption::SubtypeDiff(name) => write!(f, "SUBTYPE_DIFF = {}", name), UserDefinedTypeRangeOption::MultirangeTypeName(name) => { write!(f, "MULTIRANGE_TYPE_NAME = {}", name) } } } } /// Options for PostgreSQL `CREATE TYPE ... ()` statement (base type definition). /// /// Base types are the lowest-level data types in PostgreSQL. To define a new base type, /// you must specify functions that convert it to and from text representation, and optionally /// binary representation and other properties. /// /// Note: This syntax uses parentheses directly after the type name, without the `AS` keyword. /// /// # PostgreSQL Documentation /// See: /// /// # Examples /// ```sql /// CREATE TYPE complex ( /// INPUT = complex_in, /// OUTPUT = complex_out, /// INTERNALLENGTH = 16, /// ALIGNMENT = double /// ); /// ``` #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum UserDefinedTypeSqlDefinitionOption { /// Function to convert from external text representation to internal: `INPUT = input_function` Input(ObjectName), /// Function to convert from internal to external text representation: `OUTPUT = output_function` Output(ObjectName), /// Function to convert from external binary representation to internal: `RECEIVE = receive_function` Receive(ObjectName), /// Function to convert from internal to external binary representation: `SEND = send_function` Send(ObjectName), /// Function to convert type modifiers from text array to internal form: `TYPMOD_IN = type_modifier_input_function` TypmodIn(ObjectName), /// Function to convert type modifiers from internal to text form: `TYPMOD_OUT = type_modifier_output_function` TypmodOut(ObjectName), /// Function to compute statistics for the data type: `ANALYZE = analyze_function` Analyze(ObjectName), /// Function to handle subscripting operations: `SUBSCRIPT = subscript_function` Subscript(ObjectName), /// Internal storage size in bytes, or VARIABLE for variable-length: `INTERNALLENGTH = { internallength | VARIABLE }` InternalLength(UserDefinedTypeInternalLength), /// Indicates values are passed by value rather than by reference: `PASSEDBYVALUE` PassedByValue, /// Storage alignment requirement (1, 2, 4, or 8 bytes): `ALIGNMENT = alignment` Alignment(Alignment), /// Storage strategy for varlena types: `STORAGE = storage` Storage(UserDefinedTypeStorage), /// Copy properties from an existing type: `LIKE = like_type` Like(ObjectName), /// Type category for implicit casting rules (single char): `CATEGORY = category` Category(char), /// Whether this type is preferred within its category: `PREFERRED = preferred` Preferred(bool), /// Default value for the type: `DEFAULT = default` Default(Expr), /// Element type for array types: `ELEMENT = element` Element(DataType), /// Delimiter character for array value display: `DELIMITER = delimiter` Delimiter(String), /// Whether the type supports collation: `COLLATABLE = collatable` Collatable(bool), } impl fmt::Display for UserDefinedTypeSqlDefinitionOption { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { UserDefinedTypeSqlDefinitionOption::Input(name) => write!(f, "INPUT = {}", name), UserDefinedTypeSqlDefinitionOption::Output(name) => write!(f, "OUTPUT = {}", name), UserDefinedTypeSqlDefinitionOption::Receive(name) => write!(f, "RECEIVE = {}", name), UserDefinedTypeSqlDefinitionOption::Send(name) => write!(f, "SEND = {}", name), UserDefinedTypeSqlDefinitionOption::TypmodIn(name) => write!(f, "TYPMOD_IN = {}", name), UserDefinedTypeSqlDefinitionOption::TypmodOut(name) => { write!(f, "TYPMOD_OUT = {}", name) } UserDefinedTypeSqlDefinitionOption::Analyze(name) => write!(f, "ANALYZE = {}", name), UserDefinedTypeSqlDefinitionOption::Subscript(name) => { write!(f, "SUBSCRIPT = {}", name) } UserDefinedTypeSqlDefinitionOption::InternalLength(len) => { write!(f, "INTERNALLENGTH = {}", len) } UserDefinedTypeSqlDefinitionOption::PassedByValue => write!(f, "PASSEDBYVALUE"), UserDefinedTypeSqlDefinitionOption::Alignment(align) => { write!(f, "ALIGNMENT = {}", align) } UserDefinedTypeSqlDefinitionOption::Storage(storage) => { write!(f, "STORAGE = {}", storage) } UserDefinedTypeSqlDefinitionOption::Like(name) => write!(f, "LIKE = {}", name), UserDefinedTypeSqlDefinitionOption::Category(c) => write!(f, "CATEGORY = '{}'", c), UserDefinedTypeSqlDefinitionOption::Preferred(b) => write!(f, "PREFERRED = {}", b), UserDefinedTypeSqlDefinitionOption::Default(expr) => write!(f, "DEFAULT = {}", expr), UserDefinedTypeSqlDefinitionOption::Element(dt) => write!(f, "ELEMENT = {}", dt), UserDefinedTypeSqlDefinitionOption::Delimiter(s) => { write!(f, "DELIMITER = '{}'", escape_single_quote_string(s)) } UserDefinedTypeSqlDefinitionOption::Collatable(b) => write!(f, "COLLATABLE = {}", b), } } } /// PARTITION statement used in ALTER TABLE et al. such as in Hive and ClickHouse SQL. /// For example, ClickHouse's OPTIMIZE TABLE supports syntax like PARTITION ID 'partition_id' and PARTITION expr. /// [ClickHouse](https://clickhouse.com/docs/en/sql-reference/statements/optimize) #[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum Partition { /// ClickHouse supports PARTITION ID 'partition_id' syntax. Identifier(Ident), /// ClickHouse supports PARTITION expr syntax. Expr(Expr), /// ClickHouse supports PART expr which represents physical partition in disk. /// [ClickHouse](https://clickhouse.com/docs/en/sql-reference/statements/alter/partition#attach-partitionpart) Part(Expr), /// Hive supports multiple partitions in PARTITION (part1, part2, ...) syntax. Partitions(Vec), } impl fmt::Display for Partition { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { Partition::Identifier(id) => write!(f, "PARTITION ID {id}"), Partition::Expr(expr) => write!(f, "PARTITION {expr}"), Partition::Part(expr) => write!(f, "PART {expr}"), Partition::Partitions(partitions) => { write!(f, "PARTITION ({})", display_comma_separated(partitions)) } } } } /// DEDUPLICATE statement used in OPTIMIZE TABLE et al. such as in ClickHouse SQL /// [ClickHouse](https://clickhouse.com/docs/en/sql-reference/statements/optimize) #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum Deduplicate { /// DEDUPLICATE ALL All, /// DEDUPLICATE BY expr ByExpression(Expr), } impl fmt::Display for Deduplicate { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { Deduplicate::All => write!(f, "DEDUPLICATE"), Deduplicate::ByExpression(expr) => write!(f, "DEDUPLICATE BY {expr}"), } } } /// Hive supports `CLUSTERED BY` statement in `CREATE TABLE`. /// Syntax: `CLUSTERED BY (col_name, ...) [SORTED BY (col_name [ASC|DESC], ...)] INTO num_buckets BUCKETS` /// /// [Hive](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+DDL#LanguageManualDDL-CreateTable) #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct ClusteredBy { /// columns used for clustering pub columns: Vec, /// optional sorted by expressions pub sorted_by: Option>, /// number of buckets pub num_buckets: Value, } impl fmt::Display for ClusteredBy { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "CLUSTERED BY ({})", display_comma_separated(&self.columns) )?; if let Some(ref sorted_by) = self.sorted_by { write!(f, " SORTED BY ({})", display_comma_separated(sorted_by))?; } write!(f, " INTO {} BUCKETS", self.num_buckets) } } /// CREATE INDEX statement. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct CreateIndex { /// index name pub name: Option, #[cfg_attr(feature = "visitor", visit(with = "visit_relation"))] /// table name pub table_name: ObjectName, /// Index type used in the statement. Can also be found inside [`CreateIndex::index_options`] /// depending on the position of the option within the statement. pub using: Option, /// columns included in the index pub columns: Vec, /// whether the index is unique pub unique: bool, /// whether the index is created concurrently pub concurrently: bool, /// IF NOT EXISTS clause pub if_not_exists: bool, /// INCLUDE clause: pub include: Vec, /// NULLS DISTINCT / NOT DISTINCT clause: pub nulls_distinct: Option, /// WITH clause: pub with: Vec, /// WHERE clause: pub predicate: Option, /// Index options: pub index_options: Vec, /// [MySQL] allows a subset of options normally used for `ALTER TABLE`: /// /// - `ALGORITHM` /// - `LOCK` /// /// [MySQL]: https://dev.mysql.com/doc/refman/8.4/en/create-index.html pub alter_options: Vec, } impl fmt::Display for CreateIndex { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "CREATE {unique}INDEX {concurrently}{if_not_exists}", unique = if self.unique { "UNIQUE " } else { "" }, concurrently = if self.concurrently { "CONCURRENTLY " } else { "" }, if_not_exists = if self.if_not_exists { "IF NOT EXISTS " } else { "" }, )?; if let Some(value) = &self.name { write!(f, "{value} ")?; } write!(f, "ON {}", self.table_name)?; if let Some(value) = &self.using { write!(f, " USING {value} ")?; } write!(f, "({})", display_comma_separated(&self.columns))?; if !self.include.is_empty() { write!(f, " INCLUDE ({})", display_comma_separated(&self.include))?; } if let Some(value) = self.nulls_distinct { if value { write!(f, " NULLS DISTINCT")?; } else { write!(f, " NULLS NOT DISTINCT")?; } } if !self.with.is_empty() { write!(f, " WITH ({})", display_comma_separated(&self.with))?; } if let Some(predicate) = &self.predicate { write!(f, " WHERE {predicate}")?; } if !self.index_options.is_empty() { write!(f, " {}", display_separated(&self.index_options, " "))?; } if !self.alter_options.is_empty() { write!(f, " {}", display_separated(&self.alter_options, " "))?; } Ok(()) } } /// CREATE TABLE statement. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct CreateTable { /// `OR REPLACE` clause pub or_replace: bool, /// `TEMP` or `TEMPORARY` clause pub temporary: bool, /// `EXTERNAL` clause pub external: bool, /// `DYNAMIC` clause pub dynamic: bool, /// `GLOBAL` clause pub global: Option, /// `IF NOT EXISTS` clause pub if_not_exists: bool, /// `TRANSIENT` clause pub transient: bool, /// `VOLATILE` clause pub volatile: bool, /// `ICEBERG` clause pub iceberg: bool, /// `SNAPSHOT` clause /// pub snapshot: bool, /// Table name #[cfg_attr(feature = "visitor", visit(with = "visit_relation"))] pub name: ObjectName, /// Column definitions pub columns: Vec, /// Table constraints pub constraints: Vec, /// Hive-specific distribution style pub hive_distribution: HiveDistributionStyle, /// Hive-specific formats like `ROW FORMAT DELIMITED` or `ROW FORMAT SERDE 'serde_class' WITH SERDEPROPERTIES (...)` pub hive_formats: Option, /// Table options pub table_options: CreateTableOptions, /// General comment for the table pub file_format: Option, /// Location of the table data pub location: Option, /// Query used to populate the table pub query: Option>, /// If the table should be created without a rowid (SQLite) pub without_rowid: bool, /// `LIKE` clause pub like: Option, /// `CLONE` clause pub clone: Option, /// Table version (for systems that support versioned tables) pub version: Option, /// For Hive dialect, the table comment is after the column definitions without `=`, /// so the `comment` field is optional and different than the comment field in the general options list. /// [Hive](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+DDL#LanguageManualDDL-CreateTable) pub comment: Option, /// ClickHouse "ON COMMIT" clause: /// pub on_commit: Option, /// ClickHouse "ON CLUSTER" clause: /// pub on_cluster: Option, /// ClickHouse "PRIMARY KEY " clause. /// pub primary_key: Option>, /// ClickHouse "ORDER BY " clause. Note that omitted ORDER BY is different /// than empty (represented as ()), the latter meaning "no sorting". /// pub order_by: Option>, /// BigQuery: A partition expression for the table. /// pub partition_by: Option>, /// BigQuery: Table clustering column list. /// /// Snowflake: Table clustering list which contains base column, expressions on base columns. /// pub cluster_by: Option>>, /// Hive: Table clustering column list. /// pub clustered_by: Option, /// Postgres `INHERITs` clause, which contains the list of tables from which /// the new table inherits. /// /// pub inherits: Option>, /// PostgreSQL `PARTITION OF` clause to create a partition of a parent table. /// Contains the parent table name. /// #[cfg_attr(feature = "visitor", visit(with = "visit_relation"))] pub partition_of: Option, /// PostgreSQL partition bound specification for PARTITION OF. /// pub for_values: Option, /// 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. pub strict: bool, /// Snowflake "COPY GRANTS" clause /// pub copy_grants: bool, /// Snowflake "ENABLE_SCHEMA_EVOLUTION" clause /// pub enable_schema_evolution: Option, /// Snowflake "CHANGE_TRACKING" clause /// pub change_tracking: Option, /// Snowflake "DATA_RETENTION_TIME_IN_DAYS" clause /// pub data_retention_time_in_days: Option, /// Snowflake "MAX_DATA_EXTENSION_TIME_IN_DAYS" clause /// pub max_data_extension_time_in_days: Option, /// Snowflake "DEFAULT_DDL_COLLATION" clause /// pub default_ddl_collation: Option, /// Snowflake "WITH AGGREGATION POLICY" clause /// pub with_aggregation_policy: Option, /// Snowflake "WITH ROW ACCESS POLICY" clause /// pub with_row_access_policy: Option, /// Snowflake `WITH STORAGE LIFECYCLE POLICY` clause /// pub with_storage_lifecycle_policy: Option, /// Snowflake "WITH TAG" clause /// pub with_tags: Option>, /// Snowflake "EXTERNAL_VOLUME" clause for Iceberg tables /// pub external_volume: Option, /// Snowflake "BASE_LOCATION" clause for Iceberg tables /// pub base_location: Option, /// Snowflake "CATALOG" clause for Iceberg tables /// pub catalog: Option, /// Snowflake "CATALOG_SYNC" clause for Iceberg tables /// pub catalog_sync: Option, /// Snowflake "STORAGE_SERIALIZATION_POLICY" clause for Iceberg tables /// pub storage_serialization_policy: Option, /// Snowflake "TARGET_LAG" clause for dybamic tables /// pub target_lag: Option, /// Snowflake "WAREHOUSE" clause for dybamic tables /// pub warehouse: Option, /// Snowflake "REFRESH_MODE" clause for dybamic tables /// pub refresh_mode: Option, /// Snowflake "INITIALIZE" clause for dybamic tables /// pub initialize: Option, /// Snowflake "REQUIRE USER" clause for dybamic tables /// pub require_user: bool, /// Redshift `DISTSTYLE` option /// pub diststyle: Option, /// Redshift `DISTKEY` option /// pub distkey: Option, /// Redshift `SORTKEY` option /// pub sortkey: Option>, /// Redshift `BACKUP` option: `BACKUP { YES | NO }` /// pub backup: Option, } impl fmt::Display for CreateTable { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { // We want to allow the following options // Empty column list, allowed by PostgreSQL: // `CREATE TABLE t ()` // No columns provided for CREATE TABLE AS: // `CREATE TABLE t AS SELECT a from t2` // Columns provided for CREATE TABLE AS: // `CREATE TABLE t (a INT) AS SELECT a from t2` write!( f, "CREATE {or_replace}{external}{global}{temporary}{transient}{volatile}{dynamic}{iceberg}{snapshot}TABLE {if_not_exists}{name}", or_replace = if self.or_replace { "OR REPLACE " } else { "" }, external = if self.external { "EXTERNAL " } else { "" }, snapshot = if self.snapshot { "SNAPSHOT " } else { "" }, global = self.global .map(|global| { if global { "GLOBAL " } else { "LOCAL " } }) .unwrap_or(""), if_not_exists = if self.if_not_exists { "IF NOT EXISTS " } else { "" }, 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 { "" }, dynamic = if self.dynamic { "DYNAMIC " } else { "" }, name = self.name, )?; if let Some(partition_of) = &self.partition_of { write!(f, " PARTITION OF {partition_of}")?; } if let Some(on_cluster) = &self.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)?; if !self.columns.is_empty() && !self.constraints.is_empty() { f.write_str(",")?; SpaceOrNewline.fmt(f)?; } Indent(DisplayCommaSeparated(&self.constraints)).fmt(f)?; NewLine.fmt(f)?; f.write_str(")")?; } else if self.query.is_none() && self.like.is_none() && self.clone.is_none() && self.partition_of.is_none() { // PostgreSQL allows `CREATE TABLE t ();`, but requires empty parens f.write_str(" ()")?; } else if let Some(CreateTableLikeKind::Parenthesized(like_in_columns_list)) = &self.like { write!(f, " ({like_in_columns_list})")?; } if let Some(for_values) = &self.for_values { write!(f, " {for_values}")?; } // 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 { write!(f, " COMMENT '{comment}'")?; } // Only for SQLite if self.without_rowid { write!(f, " WITHOUT ROWID")?; } if let Some(CreateTableLikeKind::Plain(like)) = &self.like { write!(f, " {like}")?; } if let Some(c) = &self.clone { write!(f, " CLONE {c}")?; } if let Some(version) = &self.version { write!(f, " {version}")?; } match &self.hive_distribution { HiveDistributionStyle::PARTITIONED { columns } => { write!(f, " PARTITIONED BY ({})", display_comma_separated(columns))?; } HiveDistributionStyle::SKEWED { columns, on, stored_as_directories, } => { write!( f, " SKEWED BY ({})) ON ({})", display_comma_separated(columns), display_comma_separated(on) )?; if *stored_as_directories { write!(f, " STORED AS DIRECTORIES")?; } } _ => (), } if let Some(clustered_by) = &self.clustered_by { write!(f, " {clustered_by}")?; } if let Some(HiveFormat { row_format, serde_properties, storage, location, }) = &self.hive_formats { match row_format { Some(HiveRowFormat::SERDE { class }) => write!(f, " ROW FORMAT SERDE '{class}'")?, Some(HiveRowFormat::DELIMITED { delimiters }) => { write!(f, " ROW FORMAT DELIMITED")?; if !delimiters.is_empty() { write!(f, " {}", display_separated(delimiters, " "))?; } } None => (), } match storage { Some(HiveIOFormat::IOF { input_format, output_format, }) => write!( f, " STORED AS INPUTFORMAT {input_format} OUTPUTFORMAT {output_format}" )?, Some(HiveIOFormat::FileFormat { format }) if !self.external => { write!(f, " STORED AS {format}")? } Some(HiveIOFormat::Using { format }) => write!(f, " USING {format}")?, _ => (), } if let Some(serde_properties) = serde_properties.as_ref() { write!( f, " WITH SERDEPROPERTIES ({})", display_comma_separated(serde_properties) )?; } if !self.external { if let Some(loc) = location { write!(f, " LOCATION '{loc}'")?; } } } if self.external { if let Some(file_format) = self.file_format { write!(f, " STORED AS {file_format}")?; } if let Some(location) = &self.location { write!(f, " LOCATION '{location}'")?; } } match &self.table_options { options @ CreateTableOptions::With(_) | options @ CreateTableOptions::Plain(_) | options @ CreateTableOptions::TableProperties(_) => write!(f, " {options}")?, _ => (), } if let Some(primary_key) = &self.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))?; } if let Some(partition_by) = self.partition_by.as_ref() { write!(f, " PARTITION BY {partition_by}")?; } 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() { write!( f, " STORAGE_SERIALIZATION_POLICY={storage_serialization_policy}" )?; } if self.copy_grants { write!(f, " COPY GRANTS")?; } if let Some(is_enabled) = self.enable_schema_evolution { write!( f, " ENABLE_SCHEMA_EVOLUTION={}", if is_enabled { "TRUE" } else { "FALSE" } )?; } if let Some(is_enabled) = self.change_tracking { write!( f, " CHANGE_TRACKING={}", if is_enabled { "TRUE" } else { "FALSE" } )?; } if let Some(data_retention_time_in_days) = self.data_retention_time_in_days { write!( f, " DATA_RETENTION_TIME_IN_DAYS={data_retention_time_in_days}", )?; } if let Some(max_data_extension_time_in_days) = self.max_data_extension_time_in_days { write!( f, " MAX_DATA_EXTENSION_TIME_IN_DAYS={max_data_extension_time_in_days}", )?; } if let Some(default_ddl_collation) = &self.default_ddl_collation { write!(f, " DEFAULT_DDL_COLLATION='{default_ddl_collation}'",)?; } if let Some(with_aggregation_policy) = &self.with_aggregation_policy { write!(f, " WITH AGGREGATION POLICY {with_aggregation_policy}",)?; } if let Some(row_access_policy) = &self.with_row_access_policy { write!(f, " {row_access_policy}",)?; } if let Some(storage_lifecycle_policy) = &self.with_storage_lifecycle_policy { write!(f, " {storage_lifecycle_policy}",)?; } if let Some(tag) = &self.with_tags { write!(f, " WITH TAG ({})", display_comma_separated(tag.as_slice()))?; } if let Some(target_lag) = &self.target_lag { write!(f, " TARGET_LAG='{target_lag}'")?; } if let Some(warehouse) = &self.warehouse { write!(f, " WAREHOUSE={warehouse}")?; } if let Some(refresh_mode) = &self.refresh_mode { write!(f, " REFRESH_MODE={refresh_mode}")?; } if let Some(initialize) = &self.initialize { write!(f, " INITIALIZE={initialize}")?; } if self.require_user { write!(f, " REQUIRE USER")?; } if self.on_commit.is_some() { let on_commit = match self.on_commit { Some(OnCommit::DeleteRows) => "ON COMMIT DELETE ROWS", Some(OnCommit::PreserveRows) => "ON COMMIT PRESERVE ROWS", Some(OnCommit::Drop) => "ON COMMIT DROP", None => "", }; write!(f, " {on_commit}")?; } if self.strict { write!(f, " STRICT")?; } if let Some(backup) = self.backup { write!(f, " BACKUP {}", if backup { "YES" } else { "NO" })?; } if let Some(diststyle) = &self.diststyle { write!(f, " DISTSTYLE {diststyle}")?; } if let Some(distkey) = &self.distkey { write!(f, " DISTKEY({distkey})")?; } if let Some(sortkey) = &self.sortkey { write!(f, " SORTKEY({})", display_comma_separated(sortkey))?; } if let Some(query) = &self.query { write!(f, " AS {query}")?; } Ok(()) } } /// PostgreSQL partition bound specification for `PARTITION OF`. /// /// Specifies partition bounds for a child partition table. /// /// See [PostgreSQL](https://www.postgresql.org/docs/current/sql-createtable.html) #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum ForValues { /// `FOR VALUES IN (expr, ...)` In(Vec), /// `FOR VALUES FROM (expr|MINVALUE|MAXVALUE, ...) TO (expr|MINVALUE|MAXVALUE, ...)` From { /// The lower bound values for the partition. from: Vec, /// The upper bound values for the partition. to: Vec, }, /// `FOR VALUES WITH (MODULUS n, REMAINDER r)` With { /// The modulus value for hash partitioning. modulus: u64, /// The remainder value for hash partitioning. remainder: u64, }, /// `DEFAULT` Default, } impl fmt::Display for ForValues { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { ForValues::In(values) => { write!(f, "FOR VALUES IN ({})", display_comma_separated(values)) } ForValues::From { from, to } => { write!( f, "FOR VALUES FROM ({}) TO ({})", display_comma_separated(from), display_comma_separated(to) ) } ForValues::With { modulus, remainder } => { write!( f, "FOR VALUES WITH (MODULUS {modulus}, REMAINDER {remainder})" ) } ForValues::Default => write!(f, "DEFAULT"), } } } /// A value in a partition bound specification. /// /// Used in RANGE partition bounds where values can be expressions, /// MINVALUE (negative infinity), or MAXVALUE (positive infinity). #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum PartitionBoundValue { /// An expression representing a partition bound value. Expr(Expr), /// Represents negative infinity in partition bounds. MinValue, /// Represents positive infinity in partition bounds. MaxValue, } impl fmt::Display for PartitionBoundValue { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { PartitionBoundValue::Expr(expr) => write!(f, "{expr}"), PartitionBoundValue::MinValue => write!(f, "MINVALUE"), PartitionBoundValue::MaxValue => write!(f, "MAXVALUE"), } } } /// Redshift distribution style for `CREATE TABLE`. /// /// See [Redshift](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_TABLE_NEW.html) #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum DistStyle { /// `DISTSTYLE AUTO` Auto, /// `DISTSTYLE EVEN` Even, /// `DISTSTYLE KEY` Key, /// `DISTSTYLE ALL` All, } impl fmt::Display for DistStyle { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { DistStyle::Auto => write!(f, "AUTO"), DistStyle::Even => write!(f, "EVEN"), DistStyle::Key => write!(f, "KEY"), DistStyle::All => write!(f, "ALL"), } } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// ```sql /// CREATE DOMAIN name [ AS ] data_type /// [ COLLATE collation ] /// [ DEFAULT expression ] /// [ domain_constraint [ ... ] ] /// /// where domain_constraint is: /// /// [ CONSTRAINT constraint_name ] /// { NOT NULL | NULL | CHECK (expression) } /// ``` /// See [PostgreSQL](https://www.postgresql.org/docs/current/sql-createdomain.html) pub struct CreateDomain { /// The name of the domain to be created. pub name: ObjectName, /// The data type of the domain. pub data_type: DataType, /// The collation of the domain. pub collation: Option, /// The default value of the domain. pub default: Option, /// The constraints of the domain. pub constraints: Vec, } impl fmt::Display for CreateDomain { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "CREATE DOMAIN {name} AS {data_type}", name = self.name, data_type = self.data_type )?; if let Some(collation) = &self.collation { write!(f, " COLLATE {collation}")?; } if let Some(default) = &self.default { write!(f, " DEFAULT {default}")?; } if !self.constraints.is_empty() { write!(f, " {}", display_separated(&self.constraints, " "))?; } Ok(()) } } /// The return type of a `CREATE FUNCTION` statement. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum FunctionReturnType { /// `RETURNS ` DataType(DataType), /// `RETURNS SETOF ` /// /// [PostgreSQL](https://www.postgresql.org/docs/current/sql-createfunction.html) SetOf(DataType), } impl fmt::Display for FunctionReturnType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { FunctionReturnType::DataType(data_type) => write!(f, "{data_type}"), FunctionReturnType::SetOf(data_type) => write!(f, "SETOF {data_type}"), } } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// CREATE FUNCTION statement pub struct CreateFunction { /// True if this is a `CREATE OR ALTER FUNCTION` statement /// /// [MsSql](https://learn.microsoft.com/en-us/sql/t-sql/statements/create-function-transact-sql?view=sql-server-ver16#or-alter) pub or_alter: bool, /// True if this is a `CREATE OR REPLACE FUNCTION` statement pub or_replace: bool, /// True if this is a `CREATE TEMPORARY FUNCTION` statement pub temporary: bool, /// True if this is a `CREATE IF NOT EXISTS FUNCTION` statement pub if_not_exists: bool, /// Name of the function to be created. pub name: ObjectName, /// List of arguments for the function. pub args: Option>, /// The return type of the function. pub return_type: Option, /// The expression that defines the function. /// /// Examples: /// ```sql /// AS ((SELECT 1)) /// AS "console.log();" /// ``` pub function_body: Option, /// Behavior attribute for the function /// /// IMMUTABLE | STABLE | VOLATILE /// /// [PostgreSQL](https://www.postgresql.org/docs/current/sql-createfunction.html) pub behavior: Option, /// CALLED ON NULL INPUT | RETURNS NULL ON NULL INPUT | STRICT /// /// [PostgreSQL](https://www.postgresql.org/docs/current/sql-createfunction.html) pub called_on_null: Option, /// PARALLEL { UNSAFE | RESTRICTED | SAFE } /// /// [PostgreSQL](https://www.postgresql.org/docs/current/sql-createfunction.html) pub parallel: Option, /// SECURITY { DEFINER | INVOKER } /// /// [PostgreSQL](https://www.postgresql.org/docs/current/sql-createfunction.html) pub security: Option, /// SET configuration_parameter clauses /// /// [PostgreSQL](https://www.postgresql.org/docs/current/sql-createfunction.html) pub set_params: Vec, /// USING ... (Hive only) pub using: Option, /// Language used in a UDF definition. /// /// Example: /// ```sql /// CREATE FUNCTION foo() LANGUAGE js AS "console.log();" /// ``` /// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language#create_a_javascript_udf) pub language: Option, /// Determinism keyword used for non-sql UDF definitions. /// /// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language#syntax_11) pub determinism_specifier: Option, /// List of options for creating the function. /// /// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language#syntax_11) pub options: Option>, /// Connection resource for a remote function. /// /// Example: /// ```sql /// CREATE FUNCTION foo() /// RETURNS FLOAT64 /// REMOTE WITH CONNECTION us.myconnection /// ``` /// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language#create_a_remote_function) pub remote_connection: Option, } impl fmt::Display for CreateFunction { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "CREATE {or_alter}{or_replace}{temp}FUNCTION {if_not_exists}{name}", name = self.name, temp = if self.temporary { "TEMPORARY " } else { "" }, or_alter = if self.or_alter { "OR ALTER " } else { "" }, or_replace = if self.or_replace { "OR REPLACE " } else { "" }, if_not_exists = if self.if_not_exists { "IF NOT EXISTS " } else { "" }, )?; if let Some(args) = &self.args { write!(f, "({})", display_comma_separated(args))?; } if let Some(return_type) = &self.return_type { write!(f, " RETURNS {return_type}")?; } if let Some(determinism_specifier) = &self.determinism_specifier { write!(f, " {determinism_specifier}")?; } if let Some(language) = &self.language { write!(f, " LANGUAGE {language}")?; } if let Some(behavior) = &self.behavior { write!(f, " {behavior}")?; } if let Some(called_on_null) = &self.called_on_null { write!(f, " {called_on_null}")?; } if let Some(parallel) = &self.parallel { write!(f, " {parallel}")?; } if let Some(security) = &self.security { write!(f, " {security}")?; } for set_param in &self.set_params { write!(f, " {set_param}")?; } if let Some(remote_connection) = &self.remote_connection { write!(f, " REMOTE WITH CONNECTION {remote_connection}")?; } if let Some(CreateFunctionBody::AsBeforeOptions { body, link_symbol }) = &self.function_body { write!(f, " AS {body}")?; if let Some(link_symbol) = link_symbol { write!(f, ", {link_symbol}")?; } } if let Some(CreateFunctionBody::Return(function_body)) = &self.function_body { write!(f, " RETURN {function_body}")?; } if let Some(CreateFunctionBody::AsReturnExpr(function_body)) = &self.function_body { write!(f, " AS RETURN {function_body}")?; } if let Some(CreateFunctionBody::AsReturnSelect(function_body)) = &self.function_body { write!(f, " AS RETURN {function_body}")?; } if let Some(using) = &self.using { write!(f, " {using}")?; } if let Some(options) = &self.options { write!( f, " OPTIONS({})", display_comma_separated(options.as_slice()) )?; } if let Some(CreateFunctionBody::AsAfterOptions(function_body)) = &self.function_body { write!(f, " AS {function_body}")?; } if let Some(CreateFunctionBody::AsBeginEnd(bes)) = &self.function_body { write!(f, " AS {bes}")?; } Ok(()) } } /// ```sql /// CREATE CONNECTOR [IF NOT EXISTS] connector_name /// [TYPE datasource_type] /// [URL datasource_url] /// [COMMENT connector_comment] /// [WITH DCPROPERTIES(property_name=property_value, ...)] /// ``` /// /// [Hive](https://cwiki.apache.org/confluence/pages/viewpage.action?pageId=27362034#LanguageManualDDL-CreateDataConnectorCreateConnector) #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct CreateConnector { /// The name of the connector to be created. pub name: Ident, /// Whether `IF NOT EXISTS` was specified. pub if_not_exists: bool, /// The type of the connector. pub connector_type: Option, /// The URL of the connector. pub url: Option, /// The comment for the connector. pub comment: Option, /// The DC properties for the connector. pub with_dcproperties: Option>, } impl fmt::Display for CreateConnector { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "CREATE CONNECTOR {if_not_exists}{name}", if_not_exists = if self.if_not_exists { "IF NOT EXISTS " } else { "" }, name = self.name, )?; if let Some(connector_type) = &self.connector_type { write!(f, " TYPE '{connector_type}'")?; } if let Some(url) = &self.url { write!(f, " URL '{url}'")?; } if let Some(comment) = &self.comment { write!(f, " COMMENT = '{comment}'")?; } if let Some(with_dcproperties) = &self.with_dcproperties { write!( f, " WITH DCPROPERTIES({})", display_comma_separated(with_dcproperties) )?; } Ok(()) } } /// An `ALTER SCHEMA` (`Statement::AlterSchema`) operation. /// /// See [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language#alter_schema_collate_statement) /// See [PostgreSQL](https://www.postgresql.org/docs/current/sql-alterschema.html) #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum AlterSchemaOperation { /// Set the default collation for the schema. SetDefaultCollate { /// The collation to set as default. collate: Expr, }, /// Add a replica to the schema. AddReplica { /// The replica to add. replica: Ident, /// Optional options for the replica. options: Option>, }, /// Drop a replica from the schema. DropReplica { /// The replica to drop. replica: Ident, }, /// Set options for the schema. SetOptionsParens { /// The options to set. options: Vec, }, /// Rename the schema. Rename { /// The new name for the schema. name: ObjectName, }, /// Change the owner of the schema. OwnerTo { /// The new owner of the schema. owner: Owner, }, } impl fmt::Display for AlterSchemaOperation { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { AlterSchemaOperation::SetDefaultCollate { collate } => { write!(f, "SET DEFAULT COLLATE {collate}") } AlterSchemaOperation::AddReplica { replica, options } => { write!(f, "ADD REPLICA {replica}")?; if let Some(options) = options { write!(f, " OPTIONS ({})", display_comma_separated(options))?; } Ok(()) } AlterSchemaOperation::DropReplica { replica } => write!(f, "DROP REPLICA {replica}"), AlterSchemaOperation::SetOptionsParens { options } => { write!(f, "SET OPTIONS ({})", display_comma_separated(options)) } AlterSchemaOperation::Rename { name } => write!(f, "RENAME TO {name}"), AlterSchemaOperation::OwnerTo { owner } => write!(f, "OWNER TO {owner}"), } } } /// `RenameTableNameKind` is the kind used in an `ALTER TABLE _ RENAME` statement. /// /// Note: [MySQL] is the only database that supports the AS keyword for this operation. /// /// [MySQL]: https://dev.mysql.com/doc/refman/8.4/en/alter-table.html #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum RenameTableNameKind { /// `AS new_table_name` As(ObjectName), /// `TO new_table_name` To(ObjectName), } impl fmt::Display for RenameTableNameKind { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { RenameTableNameKind::As(name) => write!(f, "AS {name}"), RenameTableNameKind::To(name) => write!(f, "TO {name}"), } } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// An `ALTER SCHEMA` (`Statement::AlterSchema`) statement. pub struct AlterSchema { /// The schema name to alter. pub name: ObjectName, /// Whether `IF EXISTS` was specified. pub if_exists: bool, /// The list of operations to perform on the schema. pub operations: Vec, } impl fmt::Display for AlterSchema { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "ALTER SCHEMA ")?; if self.if_exists { write!(f, "IF EXISTS ")?; } write!(f, "{}", self.name)?; for operation in &self.operations { write!(f, " {operation}")?; } Ok(()) } } impl Spanned for RenameTableNameKind { fn span(&self) -> Span { match self { RenameTableNameKind::As(name) => name.span(), RenameTableNameKind::To(name) => name.span(), } } } #[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Whether the syntax used for the trigger object (ROW or STATEMENT) is `FOR` or `FOR EACH`. pub enum TriggerObjectKind { /// The `FOR` syntax is used. For(TriggerObject), /// The `FOR EACH` syntax is used. ForEach(TriggerObject), } impl Display for TriggerObjectKind { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { TriggerObjectKind::For(obj) => write!(f, "FOR {obj}"), TriggerObjectKind::ForEach(obj) => write!(f, "FOR EACH {obj}"), } } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// CREATE TRIGGER /// /// Examples: /// /// ```sql /// CREATE TRIGGER trigger_name /// BEFORE INSERT ON table_name /// FOR EACH ROW /// EXECUTE FUNCTION trigger_function(); /// ``` /// /// Postgres: /// SQL Server: pub struct CreateTrigger { /// True if this is a `CREATE OR ALTER TRIGGER` statement /// /// [MsSql](https://learn.microsoft.com/en-us/sql/t-sql/statements/create-trigger-transact-sql?view=sql-server-ver16#arguments) pub or_alter: bool, /// True if this is a temporary trigger. /// /// Examples: /// /// ```sql /// CREATE TEMP TRIGGER trigger_name /// ``` /// /// or /// /// ```sql /// CREATE TEMPORARY TRIGGER trigger_name; /// CREATE TEMP TRIGGER trigger_name; /// ``` /// /// [SQLite](https://sqlite.org/lang_createtrigger.html#temp_triggers_on_non_temp_tables) pub temporary: bool, /// The `OR REPLACE` clause is used to re-create the trigger if it already exists. /// /// Example: /// ```sql /// CREATE OR REPLACE TRIGGER trigger_name /// AFTER INSERT ON table_name /// FOR EACH ROW /// EXECUTE FUNCTION trigger_function(); /// ``` pub or_replace: bool, /// The `CONSTRAINT` keyword is used to create a trigger as a constraint. pub is_constraint: bool, /// The name of the trigger to be created. pub name: ObjectName, /// Determines whether the function is called before, after, or instead of the event. /// /// Example of BEFORE: /// /// ```sql /// CREATE TRIGGER trigger_name /// BEFORE INSERT ON table_name /// FOR EACH ROW /// EXECUTE FUNCTION trigger_function(); /// ``` /// /// Example of AFTER: /// /// ```sql /// CREATE TRIGGER trigger_name /// AFTER INSERT ON table_name /// FOR EACH ROW /// EXECUTE FUNCTION trigger_function(); /// ``` /// /// Example of INSTEAD OF: /// /// ```sql /// CREATE TRIGGER trigger_name /// INSTEAD OF INSERT ON table_name /// FOR EACH ROW /// EXECUTE FUNCTION trigger_function(); /// ``` pub period: Option, /// Whether the trigger period was specified before the target table name. /// This does not refer to whether the period is BEFORE, AFTER, or INSTEAD OF, /// but rather the position of the period clause in relation to the table name. /// /// ```sql /// -- period_before_table == true: Postgres, MySQL, and standard SQL /// CREATE TRIGGER t BEFORE INSERT ON table_name ...; /// -- period_before_table == false: MSSQL /// CREATE TRIGGER t ON table_name BEFORE INSERT ...; /// ``` pub period_before_table: bool, /// Multiple events can be specified using OR, such as `INSERT`, `UPDATE`, `DELETE`, or `TRUNCATE`. pub events: Vec, /// The table on which the trigger is to be created. pub table_name: ObjectName, /// The optional referenced table name that can be referenced via /// the `FROM` keyword. pub referenced_table_name: Option, /// This keyword immediately precedes the declaration of one or two relation names that provide access to the transition relations of the triggering statement. pub referencing: Vec, /// This specifies whether the trigger function should be fired once for /// every row affected by the trigger event, or just once per SQL statement. /// This is optional in some SQL dialects, such as SQLite, and if not specified, in /// those cases, the implied default is `FOR EACH ROW`. pub trigger_object: Option, /// Triggering conditions pub condition: Option, /// Execute logic block pub exec_body: Option, /// For MSSQL and dialects where statements are preceded by `AS` pub statements_as: bool, /// For SQL dialects with statement(s) for a body pub statements: Option, /// The characteristic of the trigger, which include whether the trigger is `DEFERRABLE`, `INITIALLY DEFERRED`, or `INITIALLY IMMEDIATE`, pub characteristics: Option, } impl Display for CreateTrigger { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { let CreateTrigger { or_alter, temporary, or_replace, is_constraint, name, period_before_table, period, events, table_name, referenced_table_name, referencing, trigger_object, condition, exec_body, statements_as, statements, characteristics, } = self; write!( f, "CREATE {temporary}{or_alter}{or_replace}{is_constraint}TRIGGER {name} ", temporary = if *temporary { "TEMPORARY " } else { "" }, or_alter = if *or_alter { "OR ALTER " } else { "" }, or_replace = if *or_replace { "OR REPLACE " } else { "" }, is_constraint = if *is_constraint { "CONSTRAINT " } else { "" }, )?; if *period_before_table { if let Some(p) = period { write!(f, "{p} ")?; } if !events.is_empty() { write!(f, "{} ", display_separated(events, " OR "))?; } write!(f, "ON {table_name}")?; } else { write!(f, "ON {table_name} ")?; if let Some(p) = period { write!(f, "{p}")?; } if !events.is_empty() { write!(f, " {}", display_separated(events, ", "))?; } } if let Some(referenced_table_name) = referenced_table_name { write!(f, " FROM {referenced_table_name}")?; } if let Some(characteristics) = characteristics { write!(f, " {characteristics}")?; } if !referencing.is_empty() { write!(f, " REFERENCING {}", display_separated(referencing, " "))?; } if let Some(trigger_object) = trigger_object { write!(f, " {trigger_object}")?; } if let Some(condition) = condition { write!(f, " WHEN {condition}")?; } if let Some(exec_body) = exec_body { write!(f, " EXECUTE {exec_body}")?; } if let Some(statements) = statements { if *statements_as { write!(f, " AS")?; } write!(f, " {statements}")?; } Ok(()) } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// DROP TRIGGER /// /// ```sql /// DROP TRIGGER [ IF EXISTS ] name ON table_name [ CASCADE | RESTRICT ] /// ``` /// pub struct DropTrigger { /// Whether to include the `IF EXISTS` clause. pub if_exists: bool, /// The name of the trigger to be dropped. pub trigger_name: ObjectName, /// The name of the table from which the trigger is to be dropped. pub table_name: Option, /// `CASCADE` or `RESTRICT` pub option: Option, } impl fmt::Display for DropTrigger { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let DropTrigger { if_exists, trigger_name, table_name, option, } = self; write!(f, "DROP TRIGGER")?; if *if_exists { write!(f, " IF EXISTS")?; } match &table_name { Some(table_name) => write!(f, " {trigger_name} ON {table_name}")?, None => write!(f, " {trigger_name}")?, }; if let Some(option) = option { write!(f, " {option}")?; } Ok(()) } } /// A `TRUNCATE` statement. /// /// ```sql /// TRUNCATE TABLE [IF EXISTS] table_names [PARTITION (partitions)] [RESTART IDENTITY | CONTINUE IDENTITY] [CASCADE | RESTRICT] [ON CLUSTER cluster_name] /// ``` #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct Truncate { /// Table names to truncate pub table_names: Vec, /// Optional partition specification pub partitions: Option>, /// TABLE - optional keyword pub table: bool, /// Snowflake/Redshift-specific option: [ IF EXISTS ] pub if_exists: bool, /// Postgres-specific option: [ RESTART IDENTITY | CONTINUE IDENTITY ] pub identity: Option, /// Postgres-specific option: [ CASCADE | RESTRICT ] pub cascade: Option, /// ClickHouse-specific option: [ ON CLUSTER cluster_name ] /// [ClickHouse](https://clickhouse.com/docs/en/sql-reference/statements/truncate/) pub on_cluster: Option, } impl fmt::Display for Truncate { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let table = if self.table { "TABLE " } else { "" }; let if_exists = if self.if_exists { "IF EXISTS " } else { "" }; write!( f, "TRUNCATE {table}{if_exists}{table_names}", table_names = display_comma_separated(&self.table_names) )?; if let Some(identity) = &self.identity { match identity { super::TruncateIdentityOption::Restart => write!(f, " RESTART IDENTITY")?, super::TruncateIdentityOption::Continue => write!(f, " CONTINUE IDENTITY")?, } } if let Some(cascade) = &self.cascade { match cascade { super::CascadeOption::Cascade => write!(f, " CASCADE")?, super::CascadeOption::Restrict => write!(f, " RESTRICT")?, } } if let Some(ref parts) = &self.partitions { if !parts.is_empty() { write!(f, " PARTITION ({})", display_comma_separated(parts))?; } } if let Some(on_cluster) = &self.on_cluster { write!(f, " ON CLUSTER {on_cluster}")?; } Ok(()) } } impl Spanned for Truncate { fn span(&self) -> Span { Span::union_iter( self.table_names.iter().map(|i| i.name.span()).chain( self.partitions .iter() .flat_map(|i| i.iter().map(|k| k.span())), ), ) } } /// An `MSCK` statement. /// /// ```sql /// MSCK [REPAIR] TABLE table_name [ADD|DROP|SYNC PARTITIONS] /// ``` /// MSCK (Hive) - MetaStore Check command #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct Msck { /// Table name to check #[cfg_attr(feature = "visitor", visit(with = "visit_relation"))] pub table_name: ObjectName, /// Whether to repair the table pub repair: bool, /// Partition action (ADD, DROP, or SYNC) pub partition_action: Option, } impl fmt::Display for Msck { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "MSCK {repair}TABLE {table}", repair = if self.repair { "REPAIR " } else { "" }, table = self.table_name )?; if let Some(pa) = &self.partition_action { write!(f, " {pa}")?; } Ok(()) } } impl Spanned for Msck { fn span(&self) -> Span { self.table_name.span() } } /// CREATE VIEW statement. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct CreateView { /// True if this is a `CREATE OR ALTER VIEW` statement /// /// [MsSql](https://learn.microsoft.com/en-us/sql/t-sql/statements/create-view-transact-sql) pub or_alter: bool, /// The `OR REPLACE` clause is used to re-create the view if it already exists. pub or_replace: bool, /// if true, has MATERIALIZED view modifier pub materialized: bool, /// Snowflake: SECURE view modifier /// pub secure: bool, /// View name pub name: ObjectName, /// If `if_not_exists` is true, this flag is set to true if the view name comes before the `IF NOT EXISTS` clause. /// Example: /// ```sql /// CREATE VIEW myview IF NOT EXISTS AS SELECT 1` /// ``` /// Otherwise, the flag is set to false if the view name comes after the clause /// Example: /// ```sql /// CREATE VIEW IF NOT EXISTS myview AS SELECT 1` /// ``` pub name_before_not_exists: bool, /// Optional column definitions pub columns: Vec, /// The query that defines the view. pub query: Box, /// Table options (e.g., WITH (..), OPTIONS (...)) pub options: CreateTableOptions, /// BigQuery: CLUSTER BY columns pub cluster_by: Vec, /// Snowflake: Views can have comments in Snowflake. /// pub comment: Option, /// if true, has RedShift [`WITH NO SCHEMA BINDING`] clause pub with_no_schema_binding: bool, /// if true, has SQLite `IF NOT EXISTS` clause pub if_not_exists: bool, /// if true, has SQLite `TEMP` or `TEMPORARY` clause pub temporary: bool, /// Snowflake: `COPY GRANTS` clause /// pub copy_grants: bool, /// if not None, has Clickhouse `TO` clause, specify the table into which to insert results /// pub to: Option, /// MySQL: Optional parameters for the view algorithm, definer, and security context pub params: Option, } impl fmt::Display for CreateView { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "CREATE {or_alter}{or_replace}", or_alter = if self.or_alter { "OR ALTER " } else { "" }, or_replace = if self.or_replace { "OR REPLACE " } else { "" }, )?; if let Some(ref params) = self.params { params.fmt(f)?; } write!( f, "{secure}{materialized}{temporary}VIEW {if_not_and_name}{to}", if_not_and_name = if self.if_not_exists { if self.name_before_not_exists { format!("{} IF NOT EXISTS", self.name) } else { format!("IF NOT EXISTS {}", self.name) } } else { format!("{}", self.name) }, secure = if self.secure { "SECURE " } else { "" }, materialized = if self.materialized { "MATERIALIZED " } else { "" }, temporary = if self.temporary { "TEMPORARY " } else { "" }, to = self .to .as_ref() .map(|to| format!(" TO {to}")) .unwrap_or_default() )?; if self.copy_grants { write!(f, " COPY GRANTS")?; } if !self.columns.is_empty() { write!(f, " ({})", display_comma_separated(&self.columns))?; } if matches!(self.options, CreateTableOptions::With(_)) { write!(f, " {}", self.options)?; } if let Some(ref comment) = self.comment { write!(f, " COMMENT = '{}'", escape_single_quote_string(comment))?; } if !self.cluster_by.is_empty() { write!( f, " CLUSTER BY ({})", display_comma_separated(&self.cluster_by) )?; } if matches!(self.options, CreateTableOptions::Options(_)) { write!(f, " {}", self.options)?; } f.write_str(" AS")?; SpaceOrNewline.fmt(f)?; self.query.fmt(f)?; if self.with_no_schema_binding { write!(f, " WITH NO SCHEMA BINDING")?; } Ok(()) } } /// CREATE EXTENSION statement /// Note: this is a PostgreSQL-specific statement #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct CreateExtension { /// Extension name pub name: Ident, /// Whether `IF NOT EXISTS` was specified for the CREATE EXTENSION. pub if_not_exists: bool, /// Whether `CASCADE` was specified for the CREATE EXTENSION. pub cascade: bool, /// Optional schema name for the extension. pub schema: Option, /// Optional version for the extension. pub version: Option, } impl fmt::Display for CreateExtension { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "CREATE EXTENSION {if_not_exists}{name}", if_not_exists = if self.if_not_exists { "IF NOT EXISTS " } else { "" }, name = self.name )?; if self.cascade || self.schema.is_some() || self.version.is_some() { write!(f, " WITH")?; if let Some(name) = &self.schema { write!(f, " SCHEMA {name}")?; } if let Some(version) = &self.version { write!(f, " VERSION {version}")?; } if self.cascade { write!(f, " CASCADE")?; } } Ok(()) } } impl Spanned for CreateExtension { fn span(&self) -> Span { Span::empty() } } /// DROP EXTENSION statement /// Note: this is a PostgreSQL-specific statement /// /// # References /// /// PostgreSQL Documentation: /// #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct DropExtension { /// One or more extension names to drop pub names: Vec, /// Whether `IF EXISTS` was specified for the DROP EXTENSION. pub if_exists: bool, /// `CASCADE` or `RESTRICT` behaviour for the drop. pub cascade_or_restrict: Option, } impl fmt::Display for DropExtension { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "DROP EXTENSION")?; if self.if_exists { write!(f, " IF EXISTS")?; } write!(f, " {}", display_comma_separated(&self.names))?; if let Some(cascade_or_restrict) = &self.cascade_or_restrict { write!(f, " {cascade_or_restrict}")?; } Ok(()) } } impl Spanned for DropExtension { fn span(&self) -> Span { Span::empty() } } /// CREATE COLLATION statement. /// Note: this is a PostgreSQL-specific statement. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct CreateCollation { /// Whether `IF NOT EXISTS` was specified. pub if_not_exists: bool, /// Name of the collation being created. pub name: ObjectName, /// Source definition for the collation. pub definition: CreateCollationDefinition, } /// Definition forms supported by `CREATE COLLATION`. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum CreateCollationDefinition { /// Create from an existing collation. /// /// ```sql /// CREATE COLLATION name FROM existing_collation /// ``` From(ObjectName), /// Create with an option list. /// /// ```sql /// CREATE COLLATION name (key = value, ...) /// ``` Options(Vec), } impl fmt::Display for CreateCollation { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "CREATE COLLATION {if_not_exists}{name}", if_not_exists = if self.if_not_exists { "IF NOT EXISTS " } else { "" }, name = self.name )?; match &self.definition { CreateCollationDefinition::From(existing_collation) => { write!(f, " FROM {existing_collation}") } CreateCollationDefinition::Options(options) => { write!(f, " ({})", display_comma_separated(options)) } } } } impl Spanned for CreateCollation { fn span(&self) -> Span { Span::empty() } } /// ALTER COLLATION statement. /// Note: this is a PostgreSQL-specific statement. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct AlterCollation { /// Name of the collation being altered. pub name: ObjectName, /// The operation to perform on the collation. pub operation: AlterCollationOperation, } /// Operations supported by `ALTER COLLATION`. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum AlterCollationOperation { /// Rename the collation. /// /// ```sql /// ALTER COLLATION name RENAME TO new_name /// ``` RenameTo { /// New collation name. new_name: Ident, }, /// Change the collation owner. /// /// ```sql /// ALTER COLLATION name OWNER TO role_name /// ``` OwnerTo(Owner), /// Move the collation to another schema. /// /// ```sql /// ALTER COLLATION name SET SCHEMA new_schema /// ``` SetSchema { /// Target schema name. schema_name: ObjectName, }, /// Refresh collation version metadata. /// /// ```sql /// ALTER COLLATION name REFRESH VERSION /// ``` RefreshVersion, } impl fmt::Display for AlterCollationOperation { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { AlterCollationOperation::RenameTo { new_name } => write!(f, "RENAME TO {new_name}"), AlterCollationOperation::OwnerTo(owner) => write!(f, "OWNER TO {owner}"), AlterCollationOperation::SetSchema { schema_name } => { write!(f, "SET SCHEMA {schema_name}") } AlterCollationOperation::RefreshVersion => write!(f, "REFRESH VERSION"), } } } impl fmt::Display for AlterCollation { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "ALTER COLLATION {} {}", self.name, self.operation) } } impl Spanned for AlterCollation { fn span(&self) -> Span { Span::empty() } } /// Table type for ALTER TABLE statements. /// Used to distinguish between regular tables, Iceberg tables, and Dynamic tables. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum AlterTableType { /// Iceberg table type /// Iceberg, /// Dynamic table type /// Dynamic, /// External table type /// External, } /// ALTER TABLE statement #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct AlterTable { /// Table name #[cfg_attr(feature = "visitor", visit(with = "visit_relation"))] pub name: ObjectName, /// Whether `IF EXISTS` was specified for the `ALTER TABLE`. pub if_exists: bool, /// Whether the `ONLY` keyword was used (restrict scope to the named table). pub only: bool, /// List of `ALTER TABLE` operations to apply. pub operations: Vec, /// Optional Hive `SET LOCATION` clause for the alter operation. pub location: Option, /// ClickHouse dialect supports `ON CLUSTER` clause for ALTER TABLE /// For example: `ALTER TABLE table_name ON CLUSTER cluster_name ADD COLUMN c UInt32` /// [ClickHouse](https://clickhouse.com/docs/en/sql-reference/statements/alter/update) pub on_cluster: Option, /// Table type: None for regular tables, Some(AlterTableType) for Iceberg or Dynamic tables pub table_type: Option, /// Token that represents the end of the statement (semicolon or EOF) pub end_token: AttachedToken, } impl fmt::Display for AlterTable { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match &self.table_type { Some(AlterTableType::Iceberg) => write!(f, "ALTER ICEBERG TABLE ")?, Some(AlterTableType::Dynamic) => write!(f, "ALTER DYNAMIC TABLE ")?, Some(AlterTableType::External) => write!(f, "ALTER EXTERNAL TABLE ")?, None => write!(f, "ALTER TABLE ")?, } if self.if_exists { write!(f, "IF EXISTS ")?; } if self.only { write!(f, "ONLY ")?; } write!(f, "{} ", &self.name)?; if let Some(cluster) = &self.on_cluster { write!(f, "ON CLUSTER {cluster} ")?; } write!(f, "{}", display_comma_separated(&self.operations))?; if let Some(loc) = &self.location { write!(f, " {loc}")? } Ok(()) } } /// DROP FUNCTION statement #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct DropFunction { /// Whether to include the `IF EXISTS` clause. pub if_exists: bool, /// One or more functions to drop pub func_desc: Vec, /// `CASCADE` or `RESTRICT` pub drop_behavior: Option, } impl fmt::Display for DropFunction { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "DROP FUNCTION{} {}", if self.if_exists { " IF EXISTS" } else { "" }, display_comma_separated(&self.func_desc), )?; if let Some(op) = &self.drop_behavior { write!(f, " {op}")?; } Ok(()) } } impl Spanned for DropFunction { fn span(&self) -> Span { Span::empty() } } /// CREATE OPERATOR statement /// See #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct CreateOperator { /// Operator name (can be schema-qualified) pub name: ObjectName, /// FUNCTION or PROCEDURE parameter (function name) pub function: ObjectName, /// Whether PROCEDURE keyword was used (vs FUNCTION) pub is_procedure: bool, /// LEFTARG parameter (left operand type) pub left_arg: Option, /// RIGHTARG parameter (right operand type) pub right_arg: Option, /// Operator options (COMMUTATOR, NEGATOR, RESTRICT, JOIN, HASHES, MERGES) pub options: Vec, } /// CREATE OPERATOR FAMILY statement /// See #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct CreateOperatorFamily { /// Operator family name (can be schema-qualified) pub name: ObjectName, /// Index method (btree, hash, gist, gin, etc.) pub using: Ident, } /// CREATE OPERATOR CLASS statement /// See #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct CreateOperatorClass { /// Operator class name (can be schema-qualified) pub name: ObjectName, /// Whether this is the default operator class for the type pub default: bool, /// The data type pub for_type: DataType, /// Index method (btree, hash, gist, gin, etc.) pub using: Ident, /// Optional operator family name pub family: Option, /// List of operator class items (operators, functions, storage) pub items: Vec, } impl fmt::Display for CreateOperator { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "CREATE OPERATOR {} (", self.name)?; let function_keyword = if self.is_procedure { "PROCEDURE" } else { "FUNCTION" }; let mut params = vec![format!("{} = {}", function_keyword, self.function)]; if let Some(left_arg) = &self.left_arg { params.push(format!("LEFTARG = {}", left_arg)); } if let Some(right_arg) = &self.right_arg { params.push(format!("RIGHTARG = {}", right_arg)); } for option in &self.options { params.push(option.to_string()); } write!(f, "{}", params.join(", "))?; write!(f, ")") } } impl fmt::Display for CreateOperatorFamily { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "CREATE OPERATOR FAMILY {} USING {}", self.name, self.using ) } } impl fmt::Display for CreateOperatorClass { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "CREATE OPERATOR CLASS {}", self.name)?; if self.default { write!(f, " DEFAULT")?; } write!(f, " FOR TYPE {} USING {}", self.for_type, self.using)?; if let Some(family) = &self.family { write!(f, " FAMILY {}", family)?; } write!(f, " AS {}", display_comma_separated(&self.items)) } } /// Operator argument types for CREATE OPERATOR CLASS #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct OperatorArgTypes { /// Left-hand operand data type for the operator. pub left: DataType, /// Right-hand operand data type for the operator. pub right: DataType, } impl fmt::Display for OperatorArgTypes { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{}, {}", self.left, self.right) } } /// An item in a CREATE OPERATOR CLASS statement #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum OperatorClassItem { /// `OPERATOR` clause describing a specific operator implementation. Operator { /// Strategy number identifying the operator position in the opclass. strategy_number: u64, /// The operator name referenced by this clause. operator_name: ObjectName, /// Optional operator argument types. op_types: Option, /// Optional purpose such as `FOR SEARCH` or `FOR ORDER BY`. purpose: Option, }, /// `FUNCTION` clause describing a support function for the operator class. Function { /// Support function number for this entry. support_number: u64, /// Optional function argument types for the operator class. op_types: Option>, /// The function name implementing the support function. function_name: ObjectName, /// Function argument types for the support function. argument_types: Vec, }, /// `STORAGE` clause specifying the storage type. Storage { /// The storage data type. storage_type: DataType, }, } /// Purpose of an operator in an operator class #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum OperatorPurpose { /// Purpose: used for index/search operations. ForSearch, /// Purpose: used for ORDER BY; optionally includes a sort family name. ForOrderBy { /// Optional sort family object name. sort_family: ObjectName, }, } impl fmt::Display for OperatorClassItem { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { OperatorClassItem::Operator { strategy_number, operator_name, op_types, purpose, } => { write!(f, "OPERATOR {strategy_number} {operator_name}")?; if let Some(types) = op_types { write!(f, " ({types})")?; } if let Some(purpose) = purpose { write!(f, " {purpose}")?; } Ok(()) } OperatorClassItem::Function { support_number, op_types, function_name, argument_types, } => { write!(f, "FUNCTION {support_number}")?; if let Some(types) = op_types { write!(f, " ({})", display_comma_separated(types))?; } write!(f, " {function_name}")?; if !argument_types.is_empty() { write!(f, "({})", display_comma_separated(argument_types))?; } Ok(()) } OperatorClassItem::Storage { storage_type } => { write!(f, "STORAGE {storage_type}") } } } } impl fmt::Display for OperatorPurpose { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { OperatorPurpose::ForSearch => write!(f, "FOR SEARCH"), OperatorPurpose::ForOrderBy { sort_family } => { write!(f, "FOR ORDER BY {sort_family}") } } } } /// `DROP OPERATOR` statement /// See #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct DropOperator { /// `IF EXISTS` clause pub if_exists: bool, /// One or more operators to drop with their signatures pub operators: Vec, /// `CASCADE or RESTRICT` pub drop_behavior: Option, } /// Operator signature for a `DROP OPERATOR` statement #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct DropOperatorSignature { /// Operator name pub name: ObjectName, /// Left operand type pub left_type: Option, /// Right operand type pub right_type: DataType, } impl fmt::Display for DropOperatorSignature { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{} (", self.name)?; if let Some(left_type) = &self.left_type { write!(f, "{}", left_type)?; } else { write!(f, "NONE")?; } write!(f, ", {})", self.right_type) } } impl fmt::Display for DropOperator { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "DROP OPERATOR")?; if self.if_exists { write!(f, " IF EXISTS")?; } write!(f, " {}", display_comma_separated(&self.operators))?; if let Some(drop_behavior) = &self.drop_behavior { write!(f, " {}", drop_behavior)?; } Ok(()) } } impl Spanned for DropOperator { fn span(&self) -> Span { Span::empty() } } /// `DROP OPERATOR FAMILY` statement /// See #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct DropOperatorFamily { /// `IF EXISTS` clause pub if_exists: bool, /// One or more operator families to drop pub names: Vec, /// Index method (btree, hash, gist, gin, etc.) pub using: Ident, /// `CASCADE or RESTRICT` pub drop_behavior: Option, } impl fmt::Display for DropOperatorFamily { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "DROP OPERATOR FAMILY")?; if self.if_exists { write!(f, " IF EXISTS")?; } write!(f, " {}", display_comma_separated(&self.names))?; write!(f, " USING {}", self.using)?; if let Some(drop_behavior) = &self.drop_behavior { write!(f, " {}", drop_behavior)?; } Ok(()) } } impl Spanned for DropOperatorFamily { fn span(&self) -> Span { Span::empty() } } /// `DROP OPERATOR CLASS` statement /// See #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct DropOperatorClass { /// `IF EXISTS` clause pub if_exists: bool, /// One or more operator classes to drop pub names: Vec, /// Index method (btree, hash, gist, gin, etc.) pub using: Ident, /// `CASCADE or RESTRICT` pub drop_behavior: Option, } impl fmt::Display for DropOperatorClass { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "DROP OPERATOR CLASS")?; if self.if_exists { write!(f, " IF EXISTS")?; } write!(f, " {}", display_comma_separated(&self.names))?; write!(f, " USING {}", self.using)?; if let Some(drop_behavior) = &self.drop_behavior { write!(f, " {}", drop_behavior)?; } Ok(()) } } impl Spanned for DropOperatorClass { fn span(&self) -> Span { Span::empty() } } /// An item in an ALTER OPERATOR FAMILY ADD statement #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum OperatorFamilyItem { /// `OPERATOR` clause in an operator family modification. Operator { /// Strategy number for the operator. strategy_number: u64, /// Operator name referenced by this entry. operator_name: ObjectName, /// Operator argument types. op_types: Vec, /// Optional purpose such as `FOR SEARCH` or `FOR ORDER BY`. purpose: Option, }, /// `FUNCTION` clause in an operator family modification. Function { /// Support function number. support_number: u64, /// Optional operator argument types for the function. op_types: Option>, /// Function name for the support function. function_name: ObjectName, /// Function argument types. argument_types: Vec, }, } /// An item in an ALTER OPERATOR FAMILY DROP statement #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum OperatorFamilyDropItem { /// `OPERATOR` clause for DROP within an operator family. Operator { /// Strategy number for the operator. strategy_number: u64, /// Operator argument types. op_types: Vec, }, /// `FUNCTION` clause for DROP within an operator family. Function { /// Support function number. support_number: u64, /// Operator argument types for the function. op_types: Vec, }, } impl fmt::Display for OperatorFamilyItem { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { OperatorFamilyItem::Operator { strategy_number, operator_name, op_types, purpose, } => { write!( f, "OPERATOR {strategy_number} {operator_name} ({})", display_comma_separated(op_types) )?; if let Some(purpose) = purpose { write!(f, " {purpose}")?; } Ok(()) } OperatorFamilyItem::Function { support_number, op_types, function_name, argument_types, } => { write!(f, "FUNCTION {support_number}")?; if let Some(types) = op_types { write!(f, " ({})", display_comma_separated(types))?; } write!(f, " {function_name}")?; if !argument_types.is_empty() { write!(f, "({})", display_comma_separated(argument_types))?; } Ok(()) } } } } impl fmt::Display for OperatorFamilyDropItem { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { OperatorFamilyDropItem::Operator { strategy_number, op_types, } => { write!( f, "OPERATOR {strategy_number} ({})", display_comma_separated(op_types) ) } OperatorFamilyDropItem::Function { support_number, op_types, } => { write!( f, "FUNCTION {support_number} ({})", display_comma_separated(op_types) ) } } } } /// `ALTER OPERATOR FAMILY` statement /// See #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct AlterOperatorFamily { /// Operator family name (can be schema-qualified) pub name: ObjectName, /// Index method (btree, hash, gist, gin, etc.) pub using: Ident, /// The operation to perform pub operation: AlterOperatorFamilyOperation, } /// An [AlterOperatorFamily] operation #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum AlterOperatorFamilyOperation { /// `ADD { OPERATOR ... | FUNCTION ... } [, ...]` Add { /// List of operator family items to add items: Vec, }, /// `DROP { OPERATOR ... | FUNCTION ... } [, ...]` Drop { /// List of operator family items to drop items: Vec, }, /// `RENAME TO new_name` RenameTo { /// The new name for the operator family. new_name: ObjectName, }, /// `OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }` OwnerTo(Owner), /// `SET SCHEMA new_schema` SetSchema { /// The target schema name. schema_name: ObjectName, }, } impl fmt::Display for AlterOperatorFamily { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "ALTER OPERATOR FAMILY {} USING {}", self.name, self.using )?; write!(f, " {}", self.operation) } } impl fmt::Display for AlterOperatorFamilyOperation { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { AlterOperatorFamilyOperation::Add { items } => { write!(f, "ADD {}", display_comma_separated(items)) } AlterOperatorFamilyOperation::Drop { items } => { write!(f, "DROP {}", display_comma_separated(items)) } AlterOperatorFamilyOperation::RenameTo { new_name } => { write!(f, "RENAME TO {new_name}") } AlterOperatorFamilyOperation::OwnerTo(owner) => { write!(f, "OWNER TO {owner}") } AlterOperatorFamilyOperation::SetSchema { schema_name } => { write!(f, "SET SCHEMA {schema_name}") } } } } impl Spanned for AlterOperatorFamily { fn span(&self) -> Span { Span::empty() } } /// `ALTER OPERATOR CLASS` statement /// See #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct AlterOperatorClass { /// Operator class name (can be schema-qualified) pub name: ObjectName, /// Index method (btree, hash, gist, gin, etc.) pub using: Ident, /// The operation to perform pub operation: AlterOperatorClassOperation, } /// An [AlterOperatorClass] operation #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum AlterOperatorClassOperation { /// `RENAME TO new_name` /// Rename the operator class to a new name. RenameTo { /// The new name for the operator class. new_name: ObjectName, }, /// `OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }` OwnerTo(Owner), /// `SET SCHEMA new_schema` /// Set the schema for the operator class. SetSchema { /// The target schema name. schema_name: ObjectName, }, } impl fmt::Display for AlterOperatorClass { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "ALTER OPERATOR CLASS {} USING {}", self.name, self.using)?; write!(f, " {}", self.operation) } } impl fmt::Display for AlterOperatorClassOperation { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { AlterOperatorClassOperation::RenameTo { new_name } => { write!(f, "RENAME TO {new_name}") } AlterOperatorClassOperation::OwnerTo(owner) => { write!(f, "OWNER TO {owner}") } AlterOperatorClassOperation::SetSchema { schema_name } => { write!(f, "SET SCHEMA {schema_name}") } } } } impl Spanned for AlterOperatorClass { fn span(&self) -> Span { Span::empty() } } /// `ALTER FUNCTION` / `ALTER AGGREGATE` statement. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct AlterFunction { /// Object type being altered. pub kind: AlterFunctionKind, /// Function or aggregate signature. pub function: FunctionDesc, /// `ORDER BY` argument list for aggregate signatures. /// /// This is only used for `ALTER AGGREGATE`. pub aggregate_order_by: Option>, /// Whether the aggregate signature uses `*`. /// /// This is only used for `ALTER AGGREGATE`. pub aggregate_star: bool, /// Operation applied to the object. pub operation: AlterFunctionOperation, } /// Function-like object type used by [`AlterFunction`]. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum AlterFunctionKind { /// `FUNCTION` Function, /// `AGGREGATE` Aggregate, } impl fmt::Display for AlterFunctionKind { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { Self::Function => write!(f, "FUNCTION"), Self::Aggregate => write!(f, "AGGREGATE"), } } } /// Operation for `ALTER FUNCTION` / `ALTER AGGREGATE`. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum AlterFunctionOperation { /// `RENAME TO new_name` RenameTo { /// New unqualified function or aggregate name. new_name: Ident, }, /// `OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }` OwnerTo(Owner), /// `SET SCHEMA schema_name` SetSchema { /// The target schema name. schema_name: ObjectName, }, /// `[ NO ] DEPENDS ON EXTENSION extension_name` DependsOnExtension { /// `true` when `NO DEPENDS ON EXTENSION`. no: bool, /// Extension name. extension_name: ObjectName, }, /// `action [ ... ] [ RESTRICT ]` (function only). Actions { /// One or more function actions. actions: Vec, /// Whether `RESTRICT` is present. restrict: bool, }, } /// Function action in `ALTER FUNCTION ... action [ ... ] [ RESTRICT ]`. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum AlterFunctionAction { /// `CALLED ON NULL INPUT` / `RETURNS NULL ON NULL INPUT` / `STRICT` CalledOnNull(FunctionCalledOnNull), /// `IMMUTABLE` / `STABLE` / `VOLATILE` Behavior(FunctionBehavior), /// `[ NOT ] LEAKPROOF` Leakproof(bool), /// `[ EXTERNAL ] SECURITY { DEFINER | INVOKER }` Security { /// Whether the optional `EXTERNAL` keyword was present. external: bool, /// Security mode. security: FunctionSecurity, }, /// `PARALLEL { UNSAFE | RESTRICTED | SAFE }` Parallel(FunctionParallel), /// `COST execution_cost` Cost(Expr), /// `ROWS result_rows` Rows(Expr), /// `SUPPORT support_function` Support(ObjectName), /// `SET configuration_parameter { TO | = } { value | DEFAULT }` /// or `SET configuration_parameter FROM CURRENT` Set(FunctionDefinitionSetParam), /// `RESET configuration_parameter` or `RESET ALL` Reset(ResetConfig), } impl fmt::Display for AlterFunction { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "ALTER {} ", self.kind)?; match self.kind { AlterFunctionKind::Function => { write!(f, "{} ", self.function)?; } AlterFunctionKind::Aggregate => { write!(f, "{}(", self.function.name)?; if self.aggregate_star { write!(f, "*")?; } else { if let Some(args) = &self.function.args { write!(f, "{}", display_comma_separated(args))?; } if let Some(order_by_args) = &self.aggregate_order_by { if self .function .args .as_ref() .is_some_and(|args| !args.is_empty()) { write!(f, " ")?; } write!(f, "ORDER BY {}", display_comma_separated(order_by_args))?; } } write!(f, ") ")?; } } write!(f, "{}", self.operation) } } impl fmt::Display for AlterFunctionOperation { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { AlterFunctionOperation::RenameTo { new_name } => { write!(f, "RENAME TO {new_name}") } AlterFunctionOperation::OwnerTo(owner) => write!(f, "OWNER TO {owner}"), AlterFunctionOperation::SetSchema { schema_name } => { write!(f, "SET SCHEMA {schema_name}") } AlterFunctionOperation::DependsOnExtension { no, extension_name } => { if *no { write!(f, "NO DEPENDS ON EXTENSION {extension_name}") } else { write!(f, "DEPENDS ON EXTENSION {extension_name}") } } AlterFunctionOperation::Actions { actions, restrict } => { write!(f, "{}", display_separated(actions, " "))?; if *restrict { write!(f, " RESTRICT")?; } Ok(()) } } } } impl fmt::Display for AlterFunctionAction { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { AlterFunctionAction::CalledOnNull(called_on_null) => write!(f, "{called_on_null}"), AlterFunctionAction::Behavior(behavior) => write!(f, "{behavior}"), AlterFunctionAction::Leakproof(leakproof) => { if *leakproof { write!(f, "LEAKPROOF") } else { write!(f, "NOT LEAKPROOF") } } AlterFunctionAction::Security { external, security } => { if *external { write!(f, "EXTERNAL ")?; } write!(f, "{security}") } AlterFunctionAction::Parallel(parallel) => write!(f, "{parallel}"), AlterFunctionAction::Cost(execution_cost) => write!(f, "COST {execution_cost}"), AlterFunctionAction::Rows(result_rows) => write!(f, "ROWS {result_rows}"), AlterFunctionAction::Support(support_function) => { write!(f, "SUPPORT {support_function}") } AlterFunctionAction::Set(set_param) => write!(f, "{set_param}"), AlterFunctionAction::Reset(reset_config) => match reset_config { ResetConfig::ALL => write!(f, "RESET ALL"), ResetConfig::ConfigName(name) => write!(f, "RESET {name}"), }, } } } impl Spanned for AlterFunction { fn span(&self) -> Span { Span::empty() } } /// CREATE POLICY statement. /// /// See [PostgreSQL](https://www.postgresql.org/docs/current/sql-createpolicy.html) #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct CreatePolicy { /// Name of the policy. pub name: Ident, /// Table the policy is defined on. #[cfg_attr(feature = "visitor", visit(with = "visit_relation"))] pub table_name: ObjectName, /// Optional policy type (e.g., `PERMISSIVE` / `RESTRICTIVE`). pub policy_type: Option, /// Optional command the policy applies to (e.g., `SELECT`). pub command: Option, /// Optional list of grantee owners. pub to: Option>, /// Optional expression for the `USING` clause. pub using: Option, /// Optional expression for the `WITH CHECK` clause. pub with_check: Option, } impl fmt::Display for CreatePolicy { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "CREATE POLICY {name} ON {table_name}", name = self.name, table_name = self.table_name, )?; if let Some(ref policy_type) = self.policy_type { write!(f, " AS {policy_type}")?; } if let Some(ref command) = self.command { write!(f, " FOR {command}")?; } if let Some(ref to) = self.to { write!(f, " TO {}", display_comma_separated(to))?; } if let Some(ref using) = self.using { write!(f, " USING ({using})")?; } if let Some(ref with_check) = self.with_check { write!(f, " WITH CHECK ({with_check})")?; } Ok(()) } } /// Policy type for a `CREATE POLICY` statement. /// ```sql /// AS [ PERMISSIVE | RESTRICTIVE ] /// ``` /// [PostgreSQL](https://www.postgresql.org/docs/current/sql-createpolicy.html) #[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum CreatePolicyType { /// Policy allows operations unless explicitly denied. Permissive, /// Policy denies operations unless explicitly allowed. Restrictive, } impl fmt::Display for CreatePolicyType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { CreatePolicyType::Permissive => write!(f, "PERMISSIVE"), CreatePolicyType::Restrictive => write!(f, "RESTRICTIVE"), } } } /// Command that a policy can apply to (FOR clause). /// ```sql /// FOR [ALL | SELECT | INSERT | UPDATE | DELETE] /// ``` /// [PostgreSQL](https://www.postgresql.org/docs/current/sql-createpolicy.html) #[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum CreatePolicyCommand { /// Applies to all commands. All, /// Applies to SELECT. Select, /// Applies to INSERT. Insert, /// Applies to UPDATE. Update, /// Applies to DELETE. Delete, } impl fmt::Display for CreatePolicyCommand { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { CreatePolicyCommand::All => write!(f, "ALL"), CreatePolicyCommand::Select => write!(f, "SELECT"), CreatePolicyCommand::Insert => write!(f, "INSERT"), CreatePolicyCommand::Update => write!(f, "UPDATE"), CreatePolicyCommand::Delete => write!(f, "DELETE"), } } } /// DROP POLICY statement. /// /// See [PostgreSQL](https://www.postgresql.org/docs/current/sql-droppolicy.html) #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct DropPolicy { /// `true` when `IF EXISTS` was present. pub if_exists: bool, /// Name of the policy to drop. pub name: Ident, /// Name of the table the policy applies to. #[cfg_attr(feature = "visitor", visit(with = "visit_relation"))] pub table_name: ObjectName, /// Optional drop behavior (`CASCADE` or `RESTRICT`). pub drop_behavior: Option, } impl fmt::Display for DropPolicy { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "DROP POLICY {if_exists}{name} ON {table_name}", if_exists = if self.if_exists { "IF EXISTS " } else { "" }, name = self.name, table_name = self.table_name )?; if let Some(ref behavior) = self.drop_behavior { write!(f, " {behavior}")?; } Ok(()) } } impl From for crate::ast::Statement { fn from(v: CreatePolicy) -> Self { crate::ast::Statement::CreatePolicy(v) } } impl From for crate::ast::Statement { fn from(v: DropPolicy) -> Self { crate::ast::Statement::DropPolicy(v) } } /// ALTER POLICY statement. /// /// ```sql /// ALTER POLICY ON [] /// ``` /// (Postgresql-specific) #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct AlterPolicy { /// Policy name to alter. pub name: Ident, /// Target table name the policy is defined on. #[cfg_attr(feature = "visitor", visit(with = "visit_relation"))] pub table_name: ObjectName, /// Optional operation specific to the policy alteration. pub operation: AlterPolicyOperation, } impl fmt::Display for AlterPolicy { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "ALTER POLICY {name} ON {table_name}{operation}", name = self.name, table_name = self.table_name, operation = self.operation ) } } impl From for crate::ast::Statement { fn from(v: AlterPolicy) -> Self { crate::ast::Statement::AlterPolicy(v) } } apache-datafusion-sqlparser-rs-0.62.0/src/ast/dml.rs000066400000000000000000000765221517524037000223270ustar00rootroot00000000000000// 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. #[cfg(not(feature = "std"))] use alloc::{boxed::Box, format, string::ToString, vec::Vec}; use core::fmt::{self, Display}; #[cfg(feature = "serde")] use serde::{Deserialize, Serialize}; #[cfg(feature = "visitor")] use sqlparser_derive::{Visit, VisitMut}; use crate::{ ast::display_separated, display_utils::{indented_list, Indent, SpaceOrNewline}, }; use super::{ display_comma_separated, helpers::attached_token::AttachedToken, query::InputFormatClause, Assignment, Expr, FromTable, Ident, InsertAliases, MysqlInsertPriority, ObjectName, OnInsert, OptimizerHint, OrderByExpr, Query, SelectInto, SelectItem, Setting, SqliteOnConflict, TableAliasWithoutColumns, TableFactor, TableObject, TableWithJoins, UpdateTableFromKind, Values, }; /// INSERT statement. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct Insert { /// Token for the `INSERT` keyword (or its substitutes) pub insert_token: AttachedToken, /// Query optimizer hints /// /// [MySQL](https://dev.mysql.com/doc/refman/8.4/en/optimizer-hints.html) /// [Oracle](https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/Comments.html#GUID-D316D545-89E2-4D54-977F-FC97815CD62E) pub optimizer_hints: Vec, /// Only for Sqlite pub or: Option, /// Only for mysql pub ignore: bool, /// INTO - optional keyword pub into: bool, /// TABLE pub table: TableObject, /// `table_name as foo` (for PostgreSQL) /// `table_name foo` (for Oracle) pub table_alias: Option, /// COLUMNS pub columns: Vec, /// Overwrite (Hive) pub overwrite: bool, /// A SQL query that specifies what to insert pub source: Option>, /// MySQL `INSERT INTO ... SET` /// See: pub assignments: Vec, /// partitioned insert (Hive) pub partitioned: Option>, /// Columns defined after PARTITION pub after_columns: Vec, /// whether the insert has the table keyword (Hive) pub has_table_keyword: bool, /// ON INSERT pub on: Option, /// RETURNING pub returning: Option>, /// OUTPUT (MSSQL) /// See pub output: Option, /// Only for mysql pub replace_into: bool, /// Only for mysql pub priority: Option, /// Only for mysql pub insert_alias: Option, /// 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>, /// 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, /// For Snowflake multi-table insert: specifies the type (`ALL` or `FIRST`) /// /// - `None` means this is a regular single-table INSERT /// - `Some(All)` means `INSERT ALL` (all matching WHEN clauses are executed) /// - `Some(First)` means `INSERT FIRST` (only the first matching WHEN clause is executed) /// /// See: pub multi_table_insert_type: Option, /// For multi-table insert: additional INTO clauses (unconditional) /// /// Used for `INSERT ALL INTO t1 INTO t2 ... SELECT ...` /// /// See: pub multi_table_into_clauses: Vec, /// For conditional multi-table insert: WHEN clauses /// /// Used for `INSERT ALL/FIRST WHEN cond THEN INTO t1 ... SELECT ...` /// /// See: pub multi_table_when_clauses: Vec, /// For conditional multi-table insert: ELSE clause /// /// See: pub multi_table_else_clause: Option>, } impl Display for Insert { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { // SQLite OR conflict has a special format: INSERT OR ... INTO table_name let table_name = if let Some(table_alias) = &self.table_alias { format!( "{table} {as_keyword}{alias}", table = self.table, as_keyword = if table_alias.explicit { "AS " } else { "" }, alias = table_alias.alias ) } else { self.table.to_string() }; if let Some(on_conflict) = self.or { f.write_str("INSERT")?; for hint in &self.optimizer_hints { write!(f, " {hint}")?; } write!(f, " {on_conflict} INTO {table_name} ")?; } else { write!( f, "{start}", start = if self.replace_into { "REPLACE" } else { "INSERT" } )?; for hint in &self.optimizer_hints { write!(f, " {hint}")?; } if let Some(priority) = self.priority { write!(f, " {priority}")?; } if self.ignore { write!(f, " IGNORE")?; } if self.overwrite { write!(f, " OVERWRITE")?; } if let Some(insert_type) = &self.multi_table_insert_type { write!(f, " {}", insert_type)?; } if self.into { write!(f, " INTO")?; } if self.has_table_keyword { write!(f, " TABLE")?; } if !table_name.is_empty() { write!(f, " {table_name} ")?; } } if !self.columns.is_empty() { write!(f, "({})", display_comma_separated(&self.columns))?; SpaceOrNewline.fmt(f)?; } if let Some(ref parts) = self.partitioned { if !parts.is_empty() { write!(f, "PARTITION ({})", display_comma_separated(parts))?; SpaceOrNewline.fmt(f)?; } } if !self.after_columns.is_empty() { write!(f, "({})", display_comma_separated(&self.after_columns))?; SpaceOrNewline.fmt(f)?; } if let Some(output) = &self.output { write!(f, "{output}")?; SpaceOrNewline.fmt(f)?; } if let Some(settings) = &self.settings { write!(f, "SETTINGS {}", display_comma_separated(settings))?; SpaceOrNewline.fmt(f)?; } for into_clause in &self.multi_table_into_clauses { SpaceOrNewline.fmt(f)?; write!(f, "{}", into_clause)?; } for when_clause in &self.multi_table_when_clauses { SpaceOrNewline.fmt(f)?; write!(f, "{}", when_clause)?; } if let Some(else_clauses) = &self.multi_table_else_clause { SpaceOrNewline.fmt(f)?; write!(f, "ELSE")?; for into_clause in else_clauses { SpaceOrNewline.fmt(f)?; write!(f, "{}", into_clause)?; } } if let Some(source) = &self.source { if !self.multi_table_into_clauses.is_empty() || !self.multi_table_when_clauses.is_empty() { SpaceOrNewline.fmt(f)?; } 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, "DEFAULT VALUES")?; } if let Some(insert_alias) = &self.insert_alias { write!(f, " AS {0}", insert_alias.row_alias)?; if let Some(col_aliases) = &insert_alias.col_aliases { if !col_aliases.is_empty() { write!(f, " ({})", display_comma_separated(col_aliases))?; } } } if let Some(on) = &self.on { write!(f, "{on}")?; } if let Some(returning) = &self.returning { SpaceOrNewline.fmt(f)?; f.write_str("RETURNING")?; indented_list(f, returning)?; } Ok(()) } } /// DELETE statement. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct Delete { /// Token for the `DELETE` keyword pub delete_token: AttachedToken, /// Query optimizer hints /// /// [MySQL](https://dev.mysql.com/doc/refman/8.4/en/optimizer-hints.html) /// [Oracle](https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/Comments.html#GUID-D316D545-89E2-4D54-977F-FC97815CD62E) pub optimizer_hints: Vec, /// Multi tables delete are supported in mysql pub tables: Vec, /// FROM pub from: FromTable, /// USING (Snowflake, Postgres, MySQL) pub using: Option>, /// WHERE pub selection: Option, /// RETURNING pub returning: Option>, /// OUTPUT (MSSQL) /// See pub output: Option, /// ORDER BY (MySQL) pub order_by: Vec, /// LIMIT (MySQL) pub limit: Option, } impl Display for Delete { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.write_str("DELETE")?; for hint in &self.optimizer_hints { f.write_str(" ")?; hint.fmt(f)?; } if !self.tables.is_empty() { indented_list(f, &self.tables)?; } match &self.from { FromTable::WithFromKeyword(from) => { f.write_str(" FROM")?; indented_list(f, from)?; } FromTable::WithoutKeyword(from) => { indented_list(f, from)?; } } if let Some(output) = &self.output { SpaceOrNewline.fmt(f)?; write!(f, "{output}")?; } if let Some(using) = &self.using { SpaceOrNewline.fmt(f)?; f.write_str("USING")?; indented_list(f, using)?; } if let Some(selection) = &self.selection { SpaceOrNewline.fmt(f)?; f.write_str("WHERE")?; SpaceOrNewline.fmt(f)?; Indent(selection).fmt(f)?; } if let Some(returning) = &self.returning { SpaceOrNewline.fmt(f)?; f.write_str("RETURNING")?; indented_list(f, returning)?; } if !self.order_by.is_empty() { SpaceOrNewline.fmt(f)?; f.write_str("ORDER BY")?; indented_list(f, &self.order_by)?; } if let Some(limit) = &self.limit { SpaceOrNewline.fmt(f)?; f.write_str("LIMIT")?; SpaceOrNewline.fmt(f)?; Indent(limit).fmt(f)?; } Ok(()) } } /// UPDATE statement. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct Update { /// Token for the `UPDATE` keyword pub update_token: AttachedToken, /// Query optimizer hints /// /// [MySQL](https://dev.mysql.com/doc/refman/8.4/en/optimizer-hints.html) /// [Oracle](https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/Comments.html#GUID-D316D545-89E2-4D54-977F-FC97815CD62E) pub optimizer_hints: Vec, /// TABLE pub table: TableWithJoins, /// Column assignments pub assignments: Vec, /// Table which provide value to be set pub from: Option, /// WHERE pub selection: Option, /// RETURNING pub returning: Option>, /// OUTPUT (MSSQL) /// See pub output: Option, /// SQLite-specific conflict resolution clause pub or: Option, /// ORDER BY (MySQL extension for single-table UPDATE) /// See pub order_by: Vec, /// LIMIT pub limit: Option, } impl Display for Update { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str("UPDATE")?; for hint in &self.optimizer_hints { f.write_str(" ")?; hint.fmt(f)?; } f.write_str(" ")?; if let Some(or) = &self.or { or.fmt(f)?; f.write_str(" ")?; } self.table.fmt(f)?; if let Some(UpdateTableFromKind::BeforeSet(from)) = &self.from { SpaceOrNewline.fmt(f)?; f.write_str("FROM")?; indented_list(f, from)?; } if !self.assignments.is_empty() { SpaceOrNewline.fmt(f)?; f.write_str("SET")?; indented_list(f, &self.assignments)?; } if let Some(output) = &self.output { SpaceOrNewline.fmt(f)?; write!(f, "{output}")?; } if let Some(UpdateTableFromKind::AfterSet(from)) = &self.from { SpaceOrNewline.fmt(f)?; f.write_str("FROM")?; indented_list(f, from)?; } if let Some(selection) = &self.selection { SpaceOrNewline.fmt(f)?; f.write_str("WHERE")?; SpaceOrNewline.fmt(f)?; Indent(selection).fmt(f)?; } if let Some(returning) = &self.returning { SpaceOrNewline.fmt(f)?; f.write_str("RETURNING")?; indented_list(f, returning)?; } if !self.order_by.is_empty() { SpaceOrNewline.fmt(f)?; f.write_str("ORDER BY")?; indented_list(f, &self.order_by)?; } if let Some(limit) = &self.limit { SpaceOrNewline.fmt(f)?; write!(f, "LIMIT {limit}")?; } Ok(()) } } /// A `MERGE` statement. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct Merge { /// The `MERGE` token that starts the statement. pub merge_token: AttachedToken, /// Query optimizer hints /// /// [Oracle](https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/Comments.html#GUID-D316D545-89E2-4D54-977F-FC97815CD62E) pub optimizer_hints: Vec, /// optional INTO keyword pub into: bool, /// Specifies the table to merge pub table: TableFactor, /// Specifies the table or subquery to join with the target table pub source: TableFactor, /// Specifies the expression on which to join the target table and source pub on: Box, /// Specifies the actions to perform when values match or do not match. pub clauses: Vec, /// Specifies the output to save changes in MSSQL pub output: Option, } impl Display for Merge { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.write_str("MERGE")?; for hint in &self.optimizer_hints { write!(f, " {hint}")?; } if self.into { write!(f, " INTO")?; } write!( f, " {table} USING {source} ", table = self.table, source = self.source )?; write!(f, "ON {on} ", on = self.on)?; write!(f, "{}", display_separated(&self.clauses, " "))?; if let Some(ref output) = self.output { write!(f, " {output}")?; } Ok(()) } } /// A `WHEN` clause within a `MERGE` Statement /// /// Example: /// ```sql /// WHEN NOT MATCHED BY SOURCE AND product LIKE '%washer%' THEN DELETE /// ``` /// [Snowflake](https://docs.snowflake.com/en/sql-reference/sql/merge) /// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/dml-syntax#merge_statement) #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct MergeClause { /// The `WHEN` token that starts the sub-expression. pub when_token: AttachedToken, /// The type of `WHEN` clause. pub clause_kind: MergeClauseKind, /// An optional predicate to further restrict the clause. pub predicate: Option, /// The action to perform when the clause is matched. pub action: MergeAction, } impl Display for MergeClause { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let MergeClause { when_token: _, clause_kind, predicate, action, } = self; write!(f, "WHEN {clause_kind}")?; if let Some(pred) = predicate { write!(f, " AND {pred}")?; } write!(f, " THEN {action}") } } /// Variant of `WHEN` clause used within a `MERGE` Statement. /// /// Example: /// ```sql /// MERGE INTO T USING U ON FALSE WHEN MATCHED THEN DELETE /// ``` /// [Snowflake](https://docs.snowflake.com/en/sql-reference/sql/merge) /// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/dml-syntax#merge_statement) #[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum MergeClauseKind { /// `WHEN MATCHED` Matched, /// `WHEN NOT MATCHED` NotMatched, /// `WHEN MATCHED BY TARGET` /// /// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/dml-syntax#merge_statement) NotMatchedByTarget, /// `WHEN MATCHED BY SOURCE` /// /// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/dml-syntax#merge_statement) NotMatchedBySource, } impl Display for MergeClauseKind { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { MergeClauseKind::Matched => write!(f, "MATCHED"), MergeClauseKind::NotMatched => write!(f, "NOT MATCHED"), MergeClauseKind::NotMatchedByTarget => write!(f, "NOT MATCHED BY TARGET"), MergeClauseKind::NotMatchedBySource => write!(f, "NOT MATCHED BY SOURCE"), } } } /// Underlying statement of a `WHEN` clause within a `MERGE` Statement /// /// Example /// ```sql /// INSERT (product, quantity) VALUES(product, quantity) /// ``` /// /// [Snowflake](https://docs.snowflake.com/en/sql-reference/sql/merge) /// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/dml-syntax#merge_statement) /// [Oracle](https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/MERGE.html) #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum MergeAction { /// An `INSERT` clause /// /// Example: /// ```sql /// INSERT (product, quantity) VALUES(product, quantity) /// ``` Insert(MergeInsertExpr), /// An `UPDATE` clause /// /// Example: /// ```sql /// UPDATE SET quantity = T.quantity + S.quantity /// ``` Update(MergeUpdateExpr), /// A plain `DELETE` clause Delete { /// The `DELETE` token that starts the sub-expression. delete_token: AttachedToken, }, } impl Display for MergeAction { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { MergeAction::Insert(insert) => { write!(f, "INSERT {insert}") } MergeAction::Update(update) => { write!(f, "UPDATE {update}") } MergeAction::Delete { .. } => { write!(f, "DELETE") } } } } /// The type of expression used to insert rows within a `MERGE` statement. /// /// [Snowflake](https://docs.snowflake.com/en/sql-reference/sql/merge) /// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/dml-syntax#merge_statement) #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum MergeInsertKind { /// The insert expression is defined from an explicit `VALUES` clause /// /// Example: /// ```sql /// INSERT VALUES(product, quantity) /// ``` Values(Values), /// The insert expression is defined using only the `ROW` keyword. /// /// Example: /// ```sql /// INSERT ROW /// ``` /// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/dml-syntax#merge_statement) Row, } impl Display for MergeInsertKind { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { MergeInsertKind::Values(values) => { write!(f, "{values}") } MergeInsertKind::Row => { write!(f, "ROW") } } } } /// The expression used to insert rows within a `MERGE` statement. /// /// Examples /// ```sql /// INSERT (product, quantity) VALUES(product, quantity) /// INSERT ROW /// ``` /// /// [Snowflake](https://docs.snowflake.com/en/sql-reference/sql/merge) /// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/dml-syntax#merge_statement) /// [Oracle](https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/MERGE.html) #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct MergeInsertExpr { /// The `INSERT` token that starts the sub-expression. pub insert_token: AttachedToken, /// Columns (if any) specified by the insert. /// /// Example: /// ```sql /// INSERT (product, quantity) VALUES(product, quantity) /// INSERT (product, quantity) ROW /// ``` pub columns: Vec, /// The token, `[VALUES | ROW]` starting `kind`. pub kind_token: AttachedToken, /// The insert type used by the statement. pub kind: MergeInsertKind, /// An optional condition to restrict the insertion (Oracle specific) pub insert_predicate: Option, } impl Display for MergeInsertExpr { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { if !self.columns.is_empty() { write!(f, "({}) ", display_comma_separated(self.columns.as_slice()))?; } write!(f, "{}", self.kind)?; if let Some(predicate) = self.insert_predicate.as_ref() { write!(f, " WHERE {}", predicate)?; } Ok(()) } } /// The expression used to update rows within a `MERGE` statement. /// /// Examples /// ```sql /// UPDATE SET quantity = T.quantity + S.quantity /// ``` /// /// [Snowflake](https://docs.snowflake.com/en/sql-reference/sql/merge) /// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/dml-syntax#merge_statement) /// [Oracle](https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/MERGE.html) #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct MergeUpdateExpr { /// The `UPDATE` token that starts the sub-expression. pub update_token: AttachedToken, /// The update assiment expressions pub assignments: Vec, /// `where_clause` for the update (Oralce specific) pub update_predicate: Option, /// `delete_clause` for the update "delete where" (Oracle specific) pub delete_predicate: Option, } impl Display for MergeUpdateExpr { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "SET {}", display_comma_separated(&self.assignments))?; if let Some(predicate) = self.update_predicate.as_ref() { write!(f, " WHERE {predicate}")?; } if let Some(predicate) = self.delete_predicate.as_ref() { write!(f, " DELETE WHERE {predicate}")?; } Ok(()) } } /// An `OUTPUT` clause on `MERGE`, `INSERT`, `UPDATE`, or `DELETE` (MSSQL). /// /// Example: /// OUTPUT $action, deleted.* INTO dbo.temp_products; /// #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum OutputClause { /// `OUTPUT` clause Output { /// The `OUTPUT` token that starts the sub-expression. output_token: AttachedToken, /// The select items to output select_items: Vec, /// Optional `INTO` table to direct the output into_table: Option, }, /// `RETURNING` clause Returning { /// The `RETURNING` token that starts the sub-expression. returning_token: AttachedToken, /// The select items to return select_items: Vec, }, } impl fmt::Display for OutputClause { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { OutputClause::Output { output_token: _, select_items, into_table, } => { f.write_str("OUTPUT ")?; display_comma_separated(select_items).fmt(f)?; if let Some(into_table) = into_table { f.write_str(" ")?; into_table.fmt(f)?; } Ok(()) } OutputClause::Returning { returning_token: _, select_items, } => { f.write_str("RETURNING ")?; display_comma_separated(select_items).fmt(f) } } } } /// A WHEN clause in a conditional multi-table INSERT. /// /// Syntax: /// ```sql /// WHEN n1 > 100 THEN /// INTO t1 /// INTO t2 (c1, c2) VALUES (n1, n2) /// ``` #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct MultiTableInsertWhenClause { /// The condition for this WHEN clause pub condition: Expr, /// The INTO clauses to execute when the condition is true pub into_clauses: Vec, } impl Display for MultiTableInsertWhenClause { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "WHEN {} THEN", self.condition)?; for into_clause in &self.into_clauses { SpaceOrNewline.fmt(f)?; write!(f, "{}", into_clause)?; } Ok(()) } } /// An INTO clause in a multi-table INSERT. /// /// Syntax: /// ```sql /// INTO [ ( [ , ... ] ) ] [ VALUES ( { | DEFAULT | NULL } [ , ... ] ) ] /// ``` #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct MultiTableInsertIntoClause { /// The target table pub table_name: ObjectName, /// The target columns (optional) pub columns: Vec, /// The VALUES clause (optional) pub values: Option, } impl Display for MultiTableInsertIntoClause { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "INTO {}", self.table_name)?; if !self.columns.is_empty() { write!(f, " ({})", display_comma_separated(&self.columns))?; } if let Some(values) = &self.values { write!(f, " VALUES ({})", display_comma_separated(&values.values))?; } Ok(()) } } /// The VALUES clause in a multi-table INSERT INTO clause. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct MultiTableInsertValues { /// The values to insert (can be column references, DEFAULT, or NULL) pub values: Vec, } /// A value in a multi-table INSERT VALUES clause. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum MultiTableInsertValue { /// A column reference or expression from the source Expr(Expr), /// The DEFAULT keyword Default, } impl Display for MultiTableInsertValue { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { MultiTableInsertValue::Expr(expr) => write!(f, "{}", expr), MultiTableInsertValue::Default => write!(f, "DEFAULT"), } } } /// The type of multi-table INSERT statement(Snowflake). /// /// See: #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum MultiTableInsertType { /// `INSERT ALL` - all matching WHEN clauses are executed All, /// `INSERT FIRST` - only the first matching WHEN clause is executed First, } impl Display for MultiTableInsertType { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { MultiTableInsertType::All => write!(f, "ALL"), MultiTableInsertType::First => write!(f, "FIRST"), } } } apache-datafusion-sqlparser-rs-0.62.0/src/ast/helpers/000077500000000000000000000000001517524037000226335ustar00rootroot00000000000000apache-datafusion-sqlparser-rs-0.62.0/src/ast/helpers/attached_token.rs000066400000000000000000000100501517524037000261520ustar00rootroot00000000000000// 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 { Some(self.cmp(other)) } } impl Ord for AttachedToken { fn cmp(&self, _: &Self) -> Ordering { Ordering::Equal } } impl Hash for AttachedToken { fn hash(&self, _state: &mut H) { // Do nothing } } impl From for AttachedToken { fn from(value: TokenWithSpan) -> Self { AttachedToken(value) } } impl From for TokenWithSpan { fn from(value: AttachedToken) -> Self { value.0 } } apache-datafusion-sqlparser-rs-0.62.0/src/ast/helpers/key_value_options.rs000066400000000000000000000101641517524037000267420ustar00rootroot00000000000000// 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::{boxed::Box, string::String, vec::Vec}; use core::fmt; use core::fmt::Formatter; #[cfg(feature = "serde")] use serde::{Deserialize, Serialize}; #[cfg(feature = "visitor")] use sqlparser_derive::{Visit, VisitMut}; use crate::ast::{display_comma_separated, display_separated, ValueWithSpan}; #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// A collection of key-value options. pub struct KeyValueOptions { /// The list of key-value options. pub options: Vec, /// The delimiter used between options. pub delimiter: KeyValueOptionsDelimiter, } #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// The delimiter used between key-value options. pub enum KeyValueOptionsDelimiter { /// Options are separated by spaces. Space, /// Options are separated by commas. Comma, } #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// A single key-value option. pub struct KeyValueOption { /// The name of the option. pub option_name: String, /// The value of the option. pub option_value: KeyValueOptionKind, } /// An option can have a single value, multiple values or a nested list of values. /// /// A value can be numeric, boolean, etc. Enum-style values are represented /// as Value::Placeholder. For example: MFA_METHOD=SMS will be represented as /// `Value::Placeholder("SMS".to_string)`. #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// The kind of value for a key-value option. pub enum KeyValueOptionKind { /// A single value. Single(ValueWithSpan), /// Multiple values. Multi(Vec), /// A nested list of key-value options. KeyValueOptions(Box), } impl fmt::Display for KeyValueOptions { fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result { let sep = match self.delimiter { KeyValueOptionsDelimiter::Space => " ", KeyValueOptionsDelimiter::Comma => ", ", }; write!(f, "{}", display_separated(&self.options, sep)) } } impl fmt::Display for KeyValueOption { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match &self.option_value { KeyValueOptionKind::Single(value) => { write!(f, "{}={value}", self.option_name)?; } KeyValueOptionKind::Multi(values) => { write!( f, "{}=({})", self.option_name, display_comma_separated(values) )?; } KeyValueOptionKind::KeyValueOptions(options) => { write!(f, "{}=({options})", self.option_name)?; } } Ok(()) } } apache-datafusion-sqlparser-rs-0.62.0/src/ast/helpers/mod.rs000066400000000000000000000024041517524037000237600ustar00rootroot00000000000000// 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. /// Helper utilities for attached tokens used by AST helpers. pub mod attached_token; /// Utilities for parsing key/value style options in helper statements. pub mod key_value_options; /// Helpers for `CREATE DATABASE` statement construction/parsing. pub mod stmt_create_database; /// Helpers for `CREATE TABLE` statement construction/parsing. pub mod stmt_create_table; /// Helpers for data loading/unloading related statements (stages, PUT, COPY INTO). pub mod stmt_data_loading; apache-datafusion-sqlparser-rs-0.62.0/src/ast/helpers/stmt_create_database.rs000066400000000000000000000332401517524037000273410ustar00rootroot00000000000000// 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. #[cfg(not(feature = "std"))] use alloc::{format, string::String, vec::Vec}; #[cfg(feature = "serde")] use serde::{Deserialize, Serialize}; #[cfg(feature = "visitor")] use sqlparser_derive::{Visit, VisitMut}; use crate::ast::{ CatalogSyncNamespaceMode, ContactEntry, ObjectName, Statement, StorageSerializationPolicy, Tag, }; use crate::parser::ParserError; /// Builder for create database statement variant ([1]). /// /// This structure helps building and accessing a create database with more ease, without needing to: /// - Match the enum itself a lot of times; or /// - Moving a lot of variables around the code. /// /// # Example /// ```rust /// use sqlparser::ast::helpers::stmt_create_database::CreateDatabaseBuilder; /// use sqlparser::ast::{ColumnDef, Ident, ObjectName}; /// let builder = CreateDatabaseBuilder::new(ObjectName::from(vec![Ident::new("database_name")])) /// .if_not_exists(true); /// // You can access internal elements with ease /// assert!(builder.if_not_exists); /// // Convert to a statement /// assert_eq!( /// builder.build().to_string(), /// "CREATE DATABASE IF NOT EXISTS database_name" /// ) /// ``` /// /// [1]: Statement::CreateDatabase #[derive(Debug, Clone, PartialEq, Eq, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct CreateDatabaseBuilder { /// The database name to create. pub db_name: ObjectName, /// Whether `IF NOT EXISTS` was specified. pub if_not_exists: bool, /// Optional storage location for the database. pub location: Option, /// Optional managed storage location. pub managed_location: Option, /// Whether `OR REPLACE` was specified. pub or_replace: bool, /// Whether the database is `TRANSIENT`. pub transient: bool, /// Optional `CLONE` source object name. pub clone: Option, /// Optional data retention time in days. pub data_retention_time_in_days: Option, /// Optional max data extension time in days. pub max_data_extension_time_in_days: Option, /// Optional external volume identifier. pub external_volume: Option, /// Optional catalog name. pub catalog: Option, /// Whether to replace invalid characters. pub replace_invalid_characters: Option, /// Optional default DDL collation. pub default_ddl_collation: Option, /// Optional storage serialization policy. pub storage_serialization_policy: Option, /// Optional comment attached to the database. pub comment: Option, /// Optional default character set (MySQL). /// /// pub default_charset: Option, /// Optional default collation (MySQL). /// /// pub default_collation: Option, /// Optional catalog sync configuration. pub catalog_sync: Option, /// Optional catalog sync namespace mode. pub catalog_sync_namespace_mode: Option, /// Optional namespace flatten delimiter for catalog sync. pub catalog_sync_namespace_flatten_delimiter: Option, /// Optional tags attached to the database. pub with_tags: Option>, /// Optional contact entries associated with the database. pub with_contacts: Option>, } impl CreateDatabaseBuilder { /// Create a new `CreateDatabaseBuilder` with the given database name. /// /// # Arguments /// /// * `name` - The name of the database to be created. pub fn new(name: ObjectName) -> Self { Self { db_name: name, if_not_exists: false, location: None, managed_location: None, or_replace: false, transient: false, clone: None, data_retention_time_in_days: None, max_data_extension_time_in_days: None, external_volume: None, catalog: None, replace_invalid_characters: None, default_ddl_collation: None, storage_serialization_policy: None, comment: None, default_charset: None, default_collation: None, catalog_sync: None, catalog_sync_namespace_mode: None, catalog_sync_namespace_flatten_delimiter: None, with_tags: None, with_contacts: None, } } /// Set the location for the database. pub fn location(mut self, location: Option) -> Self { self.location = location; self } /// Set the managed location for the database. pub fn managed_location(mut self, managed_location: Option) -> Self { self.managed_location = managed_location; self } /// Set whether this is an `OR REPLACE` operation. pub fn or_replace(mut self, or_replace: bool) -> Self { self.or_replace = or_replace; self } /// Set whether this is a transient database. pub fn transient(mut self, transient: bool) -> Self { self.transient = transient; self } /// Set whether to use `IF NOT EXISTS`. pub fn if_not_exists(mut self, if_not_exists: bool) -> Self { self.if_not_exists = if_not_exists; self } /// Set the clone clause for the database. pub fn clone_clause(mut self, clone: Option) -> Self { self.clone = clone; self } /// Set the data retention time in days. pub fn data_retention_time_in_days(mut self, data_retention_time_in_days: Option) -> Self { self.data_retention_time_in_days = data_retention_time_in_days; self } /// Set the maximum data extension time in days. pub fn max_data_extension_time_in_days( mut self, max_data_extension_time_in_days: Option, ) -> Self { self.max_data_extension_time_in_days = max_data_extension_time_in_days; self } /// Set the external volume for the database. pub fn external_volume(mut self, external_volume: Option) -> Self { self.external_volume = external_volume; self } /// Set the catalog for the database. pub fn catalog(mut self, catalog: Option) -> Self { self.catalog = catalog; self } /// Set whether to replace invalid characters. pub fn replace_invalid_characters(mut self, replace_invalid_characters: Option) -> Self { self.replace_invalid_characters = replace_invalid_characters; self } /// Set the default DDL collation. pub fn default_ddl_collation(mut self, default_ddl_collation: Option) -> Self { self.default_ddl_collation = default_ddl_collation; self } /// Set the storage serialization policy. pub fn storage_serialization_policy( mut self, storage_serialization_policy: Option, ) -> Self { self.storage_serialization_policy = storage_serialization_policy; self } /// Set the comment for the database. pub fn comment(mut self, comment: Option) -> Self { self.comment = comment; self } /// Set the default character set for the database. pub fn default_charset(mut self, default_charset: Option) -> Self { self.default_charset = default_charset; self } /// Set the default collation for the database. pub fn default_collation(mut self, default_collation: Option) -> Self { self.default_collation = default_collation; self } /// Set the catalog sync for the database. pub fn catalog_sync(mut self, catalog_sync: Option) -> Self { self.catalog_sync = catalog_sync; self } /// Set the catalog sync namespace mode for the database. pub fn catalog_sync_namespace_mode( mut self, catalog_sync_namespace_mode: Option, ) -> Self { self.catalog_sync_namespace_mode = catalog_sync_namespace_mode; self } /// Set the catalog sync namespace flatten delimiter for the database. pub fn catalog_sync_namespace_flatten_delimiter( mut self, catalog_sync_namespace_flatten_delimiter: Option, ) -> Self { self.catalog_sync_namespace_flatten_delimiter = catalog_sync_namespace_flatten_delimiter; self } /// Set the tags for the database. pub fn with_tags(mut self, with_tags: Option>) -> Self { self.with_tags = with_tags; self } /// Set the contacts for the database. pub fn with_contacts(mut self, with_contacts: Option>) -> Self { self.with_contacts = with_contacts; self } /// Build the `CREATE DATABASE` statement. pub fn build(self) -> Statement { Statement::CreateDatabase { db_name: self.db_name, if_not_exists: self.if_not_exists, managed_location: self.managed_location, location: self.location, or_replace: self.or_replace, transient: self.transient, clone: self.clone, data_retention_time_in_days: self.data_retention_time_in_days, max_data_extension_time_in_days: self.max_data_extension_time_in_days, external_volume: self.external_volume, catalog: self.catalog, replace_invalid_characters: self.replace_invalid_characters, default_ddl_collation: self.default_ddl_collation, storage_serialization_policy: self.storage_serialization_policy, comment: self.comment, default_charset: self.default_charset, default_collation: self.default_collation, catalog_sync: self.catalog_sync, catalog_sync_namespace_mode: self.catalog_sync_namespace_mode, catalog_sync_namespace_flatten_delimiter: self.catalog_sync_namespace_flatten_delimiter, with_tags: self.with_tags, with_contacts: self.with_contacts, } } } impl TryFrom for CreateDatabaseBuilder { type Error = ParserError; fn try_from(stmt: Statement) -> Result { match stmt { Statement::CreateDatabase { db_name, if_not_exists, location, managed_location, or_replace, transient, clone, data_retention_time_in_days, max_data_extension_time_in_days, external_volume, catalog, replace_invalid_characters, default_ddl_collation, storage_serialization_policy, comment, default_charset, default_collation, catalog_sync, catalog_sync_namespace_mode, catalog_sync_namespace_flatten_delimiter, with_tags, with_contacts, } => Ok(Self { db_name, if_not_exists, location, managed_location, or_replace, transient, clone, data_retention_time_in_days, max_data_extension_time_in_days, external_volume, catalog, replace_invalid_characters, default_ddl_collation, storage_serialization_policy, comment, default_charset, default_collation, catalog_sync, catalog_sync_namespace_mode, catalog_sync_namespace_flatten_delimiter, with_tags, with_contacts, }), _ => Err(ParserError::ParserError(format!( "Expected create database statement, but received: {stmt}" ))), } } } #[cfg(test)] mod tests { use crate::ast::helpers::stmt_create_database::CreateDatabaseBuilder; use crate::ast::{Ident, ObjectName, Statement}; use crate::parser::ParserError; #[test] pub fn test_from_valid_statement() { let builder = CreateDatabaseBuilder::new(ObjectName::from(vec![Ident::new("db_name")])); let stmt = builder.clone().build(); assert_eq!(builder, CreateDatabaseBuilder::try_from(stmt).unwrap()); } #[test] pub fn test_from_invalid_statement() { let stmt = Statement::Commit { chain: false, end: false, modifier: None, }; assert_eq!( CreateDatabaseBuilder::try_from(stmt).unwrap_err(), ParserError::ParserError( "Expected create database statement, but received: COMMIT".to_owned() ) ); } } apache-datafusion-sqlparser-rs-0.62.0/src/ast/helpers/stmt_create_table.rs000066400000000000000000000656751517524037000267050ustar00rootroot00000000000000// 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. #[cfg(not(feature = "std"))] use alloc::{boxed::Box, format, string::String, vec, vec::Vec}; #[cfg(feature = "serde")] use serde::{Deserialize, Serialize}; #[cfg(feature = "visitor")] use sqlparser_derive::{Visit, VisitMut}; use crate::ast::{ ClusteredBy, ColumnDef, CommentDef, CreateTable, CreateTableLikeKind, CreateTableOptions, DistStyle, Expr, FileFormat, ForValues, HiveDistributionStyle, HiveFormat, Ident, InitializeKind, ObjectName, OnCommit, OneOrManyWithParens, Query, RefreshModeKind, RowAccessPolicy, Statement, StorageLifecyclePolicy, StorageSerializationPolicy, TableConstraint, TableVersion, Tag, WrappedCollection, }; use crate::parser::ParserError; /// Builder for create table statement variant ([1]). /// /// This structure helps building and accessing a create table with more ease, without needing to: /// - Match the enum itself a lot of times; or /// - Moving a lot of variables around the code. /// /// # Example /// ```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")])) /// .if_not_exists(true) /// .columns(vec![ColumnDef { /// name: Ident::new("c1"), /// data_type: DataType::Int(None), /// options: vec![], /// }]); /// // You can access internal elements with ease /// assert!(builder.if_not_exists); /// // Convert to a statement /// assert_eq!( /// builder.build().to_string(), /// "CREATE TABLE IF NOT EXISTS table_name (c1 INT)" /// ) /// ``` /// /// [1]: crate::ast::Statement::CreateTable #[derive(Debug, Clone, PartialEq, Eq, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct CreateTableBuilder { /// Whether the statement uses `OR REPLACE`. pub or_replace: bool, /// Whether the table is `TEMPORARY`. pub temporary: bool, /// Whether the table is `EXTERNAL`. pub external: bool, /// Optional `GLOBAL` flag for dialects that support it. pub global: Option, /// Whether `IF NOT EXISTS` was specified. pub if_not_exists: bool, /// Whether `TRANSIENT` was specified. pub transient: bool, /// Whether `VOLATILE` was specified. pub volatile: bool, /// Iceberg-specific table flag. pub iceberg: bool, /// `SNAPSHOT` table flag. pub snapshot: bool, /// Whether `DYNAMIC` table option is set. pub dynamic: bool, /// The table name. pub name: ObjectName, /// Column definitions for the table. pub columns: Vec, /// Table-level constraints. pub constraints: Vec, /// Hive distribution style. pub hive_distribution: HiveDistributionStyle, /// Optional Hive format settings. pub hive_formats: Option, /// Optional file format for storage. pub file_format: Option, /// Optional storage location. pub location: Option, /// Optional `AS SELECT` query for the table. pub query: Option>, /// Whether `WITHOUT ROWID` is set. pub without_rowid: bool, /// Optional `LIKE` clause kind. pub like: Option, /// Optional `CLONE` source object name. pub clone: Option, /// Optional table version. pub version: Option, /// Optional table comment. pub comment: Option, /// Optional `ON COMMIT` behavior. pub on_commit: Option, /// Optional cluster identifier. pub on_cluster: Option, /// Optional primary key expression. pub primary_key: Option>, /// Optional `ORDER BY` for clustering/sorting. pub order_by: Option>, /// Optional `PARTITION BY` expression. pub partition_by: Option>, /// Optional `CLUSTER BY` expressions. pub cluster_by: Option>>, /// Optional `CLUSTERED BY` clause. pub clustered_by: Option, /// Optional parent tables (`INHERITS`). pub inherits: Option>, /// Optional partitioned table (`PARTITION OF`) pub partition_of: Option, /// Range of values associated with the partition (`FOR VALUES`) pub for_values: Option, /// `STRICT` table flag. pub strict: bool, /// Whether to copy grants from the source. pub copy_grants: bool, /// Optional flag for schema evolution support. pub enable_schema_evolution: Option, /// Optional change tracking flag. pub change_tracking: Option, /// Optional data retention time in days. pub data_retention_time_in_days: Option, /// Optional max data extension time in days. pub max_data_extension_time_in_days: Option, /// Optional default DDL collation. pub default_ddl_collation: Option, /// Optional aggregation policy object name. pub with_aggregation_policy: Option, /// Optional row access policy applied to the table. pub with_row_access_policy: Option, /// Optional storage lifecycle policy applied to the table. pub with_storage_lifecycle_policy: Option, /// Optional tags/labels attached to the table metadata. pub with_tags: Option>, /// Optional base location for staged data. pub base_location: Option, /// Optional external volume identifier. pub external_volume: Option, /// Optional catalog name. pub catalog: Option, /// Optional catalog synchronization option. pub catalog_sync: Option, /// Optional storage serialization policy. pub storage_serialization_policy: Option, /// Parsed table options from the statement. pub table_options: CreateTableOptions, /// Optional target lag configuration. pub target_lag: Option, /// Optional warehouse identifier. pub warehouse: Option, /// Optional refresh mode for materialized tables. pub refresh_mode: Option, /// Optional initialization kind for the table. pub initialize: Option, /// Whether operations require a user identity. pub require_user: bool, /// Redshift `DISTSTYLE` option. pub diststyle: Option, /// Redshift `DISTKEY` option. pub distkey: Option, /// Redshift `SORTKEY` option. pub sortkey: Option>, /// Redshift `BACKUP` option. pub backup: Option, } impl CreateTableBuilder { /// Create a new `CreateTableBuilder` for the given table name. pub fn new(name: ObjectName) -> Self { Self { or_replace: false, temporary: false, external: false, global: None, if_not_exists: false, transient: false, volatile: false, iceberg: false, snapshot: false, dynamic: false, name, columns: vec![], constraints: vec![], hive_distribution: HiveDistributionStyle::NONE, hive_formats: None, file_format: None, location: None, query: None, without_rowid: false, like: None, clone: None, version: None, comment: None, on_commit: None, on_cluster: None, primary_key: None, order_by: None, partition_by: None, cluster_by: None, clustered_by: None, inherits: None, partition_of: None, for_values: None, strict: false, copy_grants: false, enable_schema_evolution: None, change_tracking: None, data_retention_time_in_days: None, max_data_extension_time_in_days: None, default_ddl_collation: None, with_aggregation_policy: None, with_row_access_policy: None, with_storage_lifecycle_policy: None, with_tags: None, base_location: None, external_volume: None, catalog: None, catalog_sync: None, storage_serialization_policy: None, table_options: CreateTableOptions::None, target_lag: None, warehouse: None, refresh_mode: None, initialize: None, require_user: false, diststyle: None, distkey: None, sortkey: None, backup: None, } } /// Set `OR REPLACE` for the CREATE TABLE statement. pub fn or_replace(mut self, or_replace: bool) -> Self { self.or_replace = or_replace; self } /// Mark the table as `TEMPORARY`. pub fn temporary(mut self, temporary: bool) -> Self { self.temporary = temporary; self } /// Mark the table as `EXTERNAL`. pub fn external(mut self, external: bool) -> Self { self.external = external; self } /// Set optional `GLOBAL` flag (dialect-specific). pub fn global(mut self, global: Option) -> Self { self.global = global; self } /// Set `IF NOT EXISTS`. pub fn if_not_exists(mut self, if_not_exists: bool) -> Self { self.if_not_exists = if_not_exists; self } /// Set `TRANSIENT` flag. pub fn transient(mut self, transient: bool) -> Self { self.transient = transient; self } /// Set `VOLATILE` flag. pub fn volatile(mut self, volatile: bool) -> Self { self.volatile = volatile; self } /// Enable Iceberg table semantics. pub fn iceberg(mut self, iceberg: bool) -> Self { self.iceberg = iceberg; self } /// Set `SNAPSHOT` table flag (BigQuery). pub fn snapshot(mut self, snapshot: bool) -> Self { self.snapshot = snapshot; self } /// Set `DYNAMIC` table option. pub fn dynamic(mut self, dynamic: bool) -> Self { self.dynamic = dynamic; self } /// Set the table column definitions. pub fn columns(mut self, columns: Vec) -> Self { self.columns = columns; self } /// Set table-level constraints. pub fn constraints(mut self, constraints: Vec) -> Self { self.constraints = constraints; self } /// Set Hive distribution style. pub fn hive_distribution(mut self, hive_distribution: HiveDistributionStyle) -> Self { self.hive_distribution = hive_distribution; self } /// Set Hive-specific formats. pub fn hive_formats(mut self, hive_formats: Option) -> Self { self.hive_formats = hive_formats; self } /// Set file format for the table (e.g., PARQUET). pub fn file_format(mut self, file_format: Option) -> Self { self.file_format = file_format; self } /// Set storage `location` for the table. pub fn location(mut self, location: Option) -> Self { self.location = location; self } /// Set an underlying `AS SELECT` query for the table. pub fn query(mut self, query: Option>) -> Self { self.query = query; self } /// Set `WITHOUT ROWID` option. pub fn without_rowid(mut self, without_rowid: bool) -> Self { self.without_rowid = without_rowid; self } /// Set `LIKE` clause for the table. pub fn like(mut self, like: Option) -> Self { self.like = like; self } // Different name to allow the object to be cloned /// Set `CLONE` source object name. pub fn clone_clause(mut self, clone: Option) -> Self { self.clone = clone; self } /// Set table `VERSION`. pub fn version(mut self, version: Option) -> Self { self.version = version; self } /// Set a comment for the table or following column definitions. pub fn comment_after_column_def(mut self, comment: Option) -> Self { self.comment = comment; self } /// Set `ON COMMIT` behavior for temporary tables. pub fn on_commit(mut self, on_commit: Option) -> Self { self.on_commit = on_commit; self } /// Set cluster identifier for the table. pub fn on_cluster(mut self, on_cluster: Option) -> Self { self.on_cluster = on_cluster; self } /// Set a primary key expression for the table. pub fn primary_key(mut self, primary_key: Option>) -> Self { self.primary_key = primary_key; self } /// Set `ORDER BY` clause for clustered/sorted tables. pub fn order_by(mut self, order_by: Option>) -> Self { self.order_by = order_by; self } /// Set `PARTITION BY` expression. pub fn partition_by(mut self, partition_by: Option>) -> Self { self.partition_by = partition_by; self } /// Set `CLUSTER BY` expression(s). pub fn cluster_by(mut self, cluster_by: Option>>) -> Self { self.cluster_by = cluster_by; self } /// Set `CLUSTERED BY` clause. pub fn clustered_by(mut self, clustered_by: Option) -> Self { self.clustered_by = clustered_by; self } /// Set parent tables via `INHERITS`. pub fn inherits(mut self, inherits: Option>) -> Self { self.inherits = inherits; self } /// Sets the table which is partitioned to create the current table. pub fn partition_of(mut self, partition_of: Option) -> Self { self.partition_of = partition_of; self } /// Sets the range of values associated with the partition. pub fn for_values(mut self, for_values: Option) -> Self { self.for_values = for_values; self } /// Set `STRICT` option. pub fn strict(mut self, strict: bool) -> Self { self.strict = strict; self } /// Enable copying grants from source object. pub fn copy_grants(mut self, copy_grants: bool) -> Self { self.copy_grants = copy_grants; self } /// Enable or disable schema evolution features. pub fn enable_schema_evolution(mut self, enable_schema_evolution: Option) -> Self { self.enable_schema_evolution = enable_schema_evolution; self } /// Enable or disable change tracking. pub fn change_tracking(mut self, change_tracking: Option) -> Self { self.change_tracking = change_tracking; self } /// Set data retention time (in days). pub fn data_retention_time_in_days(mut self, data_retention_time_in_days: Option) -> Self { self.data_retention_time_in_days = data_retention_time_in_days; self } /// Set maximum data extension time (in days). pub fn max_data_extension_time_in_days( mut self, max_data_extension_time_in_days: Option, ) -> Self { self.max_data_extension_time_in_days = max_data_extension_time_in_days; self } /// Set default DDL collation. pub fn default_ddl_collation(mut self, default_ddl_collation: Option) -> Self { self.default_ddl_collation = default_ddl_collation; self } /// Set aggregation policy object. pub fn with_aggregation_policy(mut self, with_aggregation_policy: Option) -> Self { self.with_aggregation_policy = with_aggregation_policy; self } /// Attach a row access policy to the table. pub fn with_row_access_policy( mut self, with_row_access_policy: Option, ) -> Self { self.with_row_access_policy = with_row_access_policy; self } /// Attach a storage lifecycle policy to the table. pub fn with_storage_lifecycle_policy( mut self, with_storage_lifecycle_policy: Option, ) -> Self { self.with_storage_lifecycle_policy = with_storage_lifecycle_policy; self } /// Attach tags/labels to the table metadata. pub fn with_tags(mut self, with_tags: Option>) -> Self { self.with_tags = with_tags; self } /// Set a base storage location for staged data. pub fn base_location(mut self, base_location: Option) -> Self { self.base_location = base_location; self } /// Set an external volume identifier. pub fn external_volume(mut self, external_volume: Option) -> Self { self.external_volume = external_volume; self } /// Set the catalog name for the table. pub fn catalog(mut self, catalog: Option) -> Self { self.catalog = catalog; self } /// Set catalog synchronization option. pub fn catalog_sync(mut self, catalog_sync: Option) -> Self { self.catalog_sync = catalog_sync; self } /// Set a storage serialization policy. pub fn storage_serialization_policy( mut self, storage_serialization_policy: Option, ) -> Self { self.storage_serialization_policy = storage_serialization_policy; self } /// Set arbitrary table options parsed from the statement. pub fn table_options(mut self, table_options: CreateTableOptions) -> Self { self.table_options = table_options; self } /// Set a target lag configuration (dialect-specific). pub fn target_lag(mut self, target_lag: Option) -> Self { self.target_lag = target_lag; self } /// Associate the table with a warehouse identifier. pub fn warehouse(mut self, warehouse: Option) -> Self { self.warehouse = warehouse; self } /// Set refresh mode for materialized/managed tables. pub fn refresh_mode(mut self, refresh_mode: Option) -> Self { self.refresh_mode = refresh_mode; self } /// Set initialization mode for the table. pub fn initialize(mut self, initialize: Option) -> Self { self.initialize = initialize; self } /// Require a user identity for table operations. pub fn require_user(mut self, require_user: bool) -> Self { self.require_user = require_user; self } /// Set Redshift `DISTSTYLE` option. pub fn diststyle(mut self, diststyle: Option) -> Self { self.diststyle = diststyle; self } /// Set Redshift `DISTKEY` option. pub fn distkey(mut self, distkey: Option) -> Self { self.distkey = distkey; self } /// Set Redshift `SORTKEY` option. pub fn sortkey(mut self, sortkey: Option>) -> Self { self.sortkey = sortkey; self } /// Set the Redshift `BACKUP` option. pub fn backup(mut self, backup: Option) -> Self { self.backup = backup; self } /// Consume the builder and produce a `CreateTable`. pub fn build(self) -> CreateTable { CreateTable { or_replace: self.or_replace, temporary: self.temporary, external: self.external, global: self.global, if_not_exists: self.if_not_exists, transient: self.transient, volatile: self.volatile, iceberg: self.iceberg, snapshot: self.snapshot, dynamic: self.dynamic, name: self.name, columns: self.columns, constraints: self.constraints, hive_distribution: self.hive_distribution, hive_formats: self.hive_formats, file_format: self.file_format, location: self.location, query: self.query, without_rowid: self.without_rowid, like: self.like, clone: self.clone, version: self.version, comment: self.comment, on_commit: self.on_commit, on_cluster: self.on_cluster, primary_key: self.primary_key, order_by: self.order_by, partition_by: self.partition_by, cluster_by: self.cluster_by, clustered_by: self.clustered_by, inherits: self.inherits, partition_of: self.partition_of, for_values: self.for_values, strict: self.strict, copy_grants: self.copy_grants, enable_schema_evolution: self.enable_schema_evolution, change_tracking: self.change_tracking, data_retention_time_in_days: self.data_retention_time_in_days, max_data_extension_time_in_days: self.max_data_extension_time_in_days, default_ddl_collation: self.default_ddl_collation, with_aggregation_policy: self.with_aggregation_policy, with_row_access_policy: self.with_row_access_policy, with_storage_lifecycle_policy: self.with_storage_lifecycle_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, target_lag: self.target_lag, warehouse: self.warehouse, refresh_mode: self.refresh_mode, initialize: self.initialize, require_user: self.require_user, diststyle: self.diststyle, distkey: self.distkey, sortkey: self.sortkey, backup: self.backup, } } } impl TryFrom for CreateTableBuilder { type Error = ParserError; // As the builder can be transformed back to a statement, it shouldn't be a problem to take the // ownership. fn try_from(stmt: Statement) -> Result { match stmt { Statement::CreateTable(create_table) => Ok(create_table.into()), _ => Err(ParserError::ParserError(format!( "Expected create table statement, but received: {stmt}" ))), } } } impl From for CreateTableBuilder { fn from(table: CreateTable) -> Self { Self { or_replace: table.or_replace, temporary: table.temporary, external: table.external, global: table.global, if_not_exists: table.if_not_exists, transient: table.transient, volatile: table.volatile, iceberg: table.iceberg, snapshot: table.snapshot, dynamic: table.dynamic, name: table.name, columns: table.columns, constraints: table.constraints, hive_distribution: table.hive_distribution, hive_formats: table.hive_formats, file_format: table.file_format, location: table.location, query: table.query, without_rowid: table.without_rowid, like: table.like, clone: table.clone, version: table.version, comment: table.comment, on_commit: table.on_commit, on_cluster: table.on_cluster, primary_key: table.primary_key, order_by: table.order_by, partition_by: table.partition_by, cluster_by: table.cluster_by, clustered_by: table.clustered_by, inherits: table.inherits, partition_of: table.partition_of, for_values: table.for_values, strict: table.strict, copy_grants: table.copy_grants, enable_schema_evolution: table.enable_schema_evolution, change_tracking: table.change_tracking, data_retention_time_in_days: table.data_retention_time_in_days, max_data_extension_time_in_days: table.max_data_extension_time_in_days, default_ddl_collation: table.default_ddl_collation, with_aggregation_policy: table.with_aggregation_policy, with_row_access_policy: table.with_row_access_policy, with_storage_lifecycle_policy: table.with_storage_lifecycle_policy, with_tags: table.with_tags, base_location: table.base_location, external_volume: table.external_volume, catalog: table.catalog, catalog_sync: table.catalog_sync, storage_serialization_policy: table.storage_serialization_policy, table_options: table.table_options, target_lag: table.target_lag, warehouse: table.warehouse, refresh_mode: table.refresh_mode, initialize: table.initialize, require_user: table.require_user, diststyle: table.diststyle, distkey: table.distkey, sortkey: table.sortkey, backup: table.backup, } } } /// Helper return type when parsing configuration for a `CREATE TABLE` statement. #[derive(Default)] pub(crate) struct CreateTableConfiguration { pub partition_by: Option>, pub cluster_by: Option>>, pub inherits: Option>, pub table_options: CreateTableOptions, } #[cfg(test)] mod tests { use crate::ast::helpers::stmt_create_table::CreateTableBuilder; use crate::ast::{Ident, ObjectName, Statement}; use crate::parser::ParserError; #[test] pub fn test_from_valid_statement() { let builder = CreateTableBuilder::new(ObjectName::from(vec![Ident::new("table_name")])); let create_table = builder.clone().build(); let stmt: Statement = create_table.into(); assert_eq!(builder, CreateTableBuilder::try_from(stmt).unwrap()); } #[test] pub fn test_from_invalid_statement() { let stmt = Statement::Commit { chain: false, end: false, modifier: None, }; assert_eq!( CreateTableBuilder::try_from(stmt).unwrap_err(), ParserError::ParserError( "Expected create table statement, but received: COMMIT".to_owned() ) ); } } apache-datafusion-sqlparser-rs-0.62.0/src/ast/helpers/stmt_data_loading.rs000066400000000000000000000127631517524037000266670ustar00rootroot00000000000000// 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. //! AST types specific to loading and unloading syntax, like one available in Snowflake which //! contains: STAGE ddl operations, PUT upload or COPY INTO //! See [this page](https://docs.snowflake.com/en/sql-reference/commands-data-loading) for more details. #[cfg(not(feature = "std"))] use alloc::string::String; use core::fmt; #[cfg(feature = "serde")] use serde::{Deserialize, Serialize}; use crate::ast::helpers::key_value_options::KeyValueOptions; use crate::ast::{Ident, ObjectName, SelectItem}; #[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))] /// Parameters for a named stage object used in data loading/unloading. pub struct StageParamsObject { /// Optional URL for the stage. pub url: Option, /// Encryption-related key/value options. pub encryption: KeyValueOptions, /// Optional endpoint string. pub endpoint: Option, /// Optional storage integration identifier. pub storage_integration: Option, /// Credentials for accessing the stage. pub credentials: KeyValueOptions, } /// This enum enables support for both standard SQL select item expressions /// and Snowflake-specific ones for data loading. #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum StageLoadSelectItemKind { /// A standard SQL select item expression. SelectItem(SelectItem), /// A Snowflake-specific select item used for stage loading. StageLoadSelectItem(StageLoadSelectItem), } 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))] /// A single item in the `SELECT` list for data loading from staged files. pub struct StageLoadSelectItem { /// Optional alias for the input source. pub alias: Option, /// Column number within the staged file (1-based). pub file_col_num: i32, /// Optional element identifier following the column reference. pub element: Option, /// Optional alias for the item (AS clause). pub item_as: Option, } impl fmt::Display for StageParamsObject { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let url = &self.url.as_ref(); let storage_integration = &self.storage_integration.as_ref(); let endpoint = &self.endpoint.as_ref(); if url.is_some() { write!(f, " URL='{}'", url.unwrap())?; } if storage_integration.is_some() { write!(f, " STORAGE_INTEGRATION={}", storage_integration.unwrap())?; } if endpoint.is_some() { write!(f, " ENDPOINT='{}'", endpoint.unwrap())?; } if !self.credentials.options.is_empty() { write!(f, " CREDENTIALS=({})", self.credentials)?; } if !self.encryption.options.is_empty() { write!(f, " ENCRYPTION=({})", self.encryption)?; } Ok(()) } } impl fmt::Display for StageLoadSelectItem { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { if let Some(alias) = &self.alias { write!(f, "{alias}.")?; } write!(f, "${}", self.file_col_num)?; if let Some(element) = &self.element { write!(f, ":{element}")?; } if let Some(item_as) = &self.item_as { write!(f, " AS {item_as}")?; } Ok(()) } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// A command to stage files to a named stage. pub struct FileStagingCommand { /// The stage to which files are being staged. #[cfg_attr(feature = "visitor", visit(with = "visit_relation"))] pub stage: ObjectName, /// Optional file matching `PATTERN` expression. pub pattern: Option, } 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(()) } } apache-datafusion-sqlparser-rs-0.62.0/src/ast/mod.rs000066400000000000000000015336561517524037000223410ustar00rootroot00000000000000// 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. //! SQL Abstract Syntax Tree (AST) types #[cfg(not(feature = "std"))] use alloc::{ boxed::Box, format, string::{String, ToString}, vec, vec::Vec, }; use helpers::{ attached_token::AttachedToken, stmt_data_loading::{FileStagingCommand, StageLoadSelectItemKind}, }; use core::cmp::Ordering; use core::ops::{Deref, DerefMut}; use core::{ fmt::{self, Display}, hash, }; #[cfg(feature = "serde")] use serde::{Deserialize, Serialize}; #[cfg(feature = "visitor")] use sqlparser_derive::{Visit, VisitMut}; use crate::{ display_utils::SpaceOrNewline, tokenizer::{Span, Token}, }; use crate::{ display_utils::{Indent, NewLine}, keywords::Keyword, }; pub use self::data_type::{ ArrayElemTypeDef, BinaryLength, CharLengthUnits, CharacterLength, DataType, EnumMember, ExactNumberInfo, IntervalFields, StructBracketKind, TimezoneInfo, }; pub use self::dcl::{ AlterRoleOperation, CreateRole, Grant, ResetConfig, Revoke, RoleOption, SecondaryRoles, SetConfigValue, Use, }; pub use self::ddl::{ Alignment, AlterCollation, AlterCollationOperation, AlterColumnOperation, AlterConnectorOwner, AlterFunction, AlterFunctionAction, AlterFunctionKind, AlterFunctionOperation, AlterIndexOperation, AlterOperator, AlterOperatorClass, AlterOperatorClassOperation, AlterOperatorFamily, AlterOperatorFamilyOperation, AlterOperatorOperation, AlterPolicy, AlterPolicyOperation, AlterSchema, AlterSchemaOperation, AlterTable, AlterTableAlgorithm, AlterTableLock, AlterTableOperation, AlterTableType, AlterType, AlterTypeAddValue, AlterTypeAddValuePosition, AlterTypeOperation, AlterTypeRename, AlterTypeRenameValue, ClusteredBy, ColumnDef, ColumnOption, ColumnOptionDef, ColumnOptions, ColumnPolicy, ColumnPolicyProperty, ConstraintCharacteristics, CreateCollation, CreateCollationDefinition, CreateConnector, CreateDomain, CreateExtension, CreateFunction, CreateIndex, CreateOperator, CreateOperatorClass, CreateOperatorFamily, CreatePolicy, CreatePolicyCommand, CreatePolicyType, CreateTable, CreateTrigger, CreateView, Deduplicate, DeferrableInitial, DistStyle, DropBehavior, DropExtension, DropFunction, DropOperator, DropOperatorClass, DropOperatorFamily, DropOperatorSignature, DropPolicy, DropTrigger, ForValues, FunctionReturnType, GeneratedAs, GeneratedExpressionMode, IdentityParameters, IdentityProperty, IdentityPropertyFormatKind, IdentityPropertyKind, IdentityPropertyOrder, IndexColumn, IndexOption, IndexType, KeyOrIndexDisplay, Msck, NullsDistinctOption, OperatorArgTypes, OperatorClassItem, OperatorFamilyDropItem, OperatorFamilyItem, OperatorOption, OperatorPurpose, Owner, Partition, PartitionBoundValue, ProcedureParam, ReferentialAction, RenameTableNameKind, ReplicaIdentity, TagsColumnOption, TriggerObjectKind, Truncate, UserDefinedTypeCompositeAttributeDef, UserDefinedTypeInternalLength, UserDefinedTypeRangeOption, UserDefinedTypeRepresentation, UserDefinedTypeSqlDefinitionOption, UserDefinedTypeStorage, ViewColumnDef, }; pub use self::dml::{ Delete, Insert, Merge, MergeAction, MergeClause, MergeClauseKind, MergeInsertExpr, MergeInsertKind, MergeUpdateExpr, MultiTableInsertIntoClause, MultiTableInsertType, MultiTableInsertValue, MultiTableInsertValues, MultiTableInsertWhenClause, OutputClause, Update, }; pub use self::operator::{BinaryOperator, UnaryOperator}; pub use self::query::{ AfterMatchSkip, ConnectByKind, Cte, CteAsMaterialized, Distinct, EmptyMatchesMode, ExceptSelectItem, ExcludeSelectItem, ExprWithAlias, ExprWithAliasAndOrderBy, Fetch, ForClause, ForJson, ForXml, FormatClause, GroupByExpr, GroupByWithModifier, IdentWithAlias, IlikeSelectItem, InputFormatClause, Interpolate, InterpolateExpr, Join, JoinConstraint, JoinOperator, JsonTableColumn, JsonTableColumnErrorHandling, JsonTableNamedColumn, JsonTableNestedColumn, LateralView, LimitClause, LockClause, LockType, MatchRecognizePattern, MatchRecognizeSymbol, Measure, NamedWindowDefinition, NamedWindowExpr, NonBlock, Offset, OffsetRows, OpenJsonTableColumn, OrderBy, OrderByExpr, OrderByKind, OrderByOptions, PipeOperator, PivotValueSource, ProjectionSelect, Query, RenameSelectItem, RepetitionQuantifier, ReplaceSelectElement, ReplaceSelectItem, RowsPerMatch, Select, SelectFlavor, SelectInto, SelectItem, SelectItemQualifiedWildcardKind, SelectModifiers, SetExpr, SetOperator, SetQuantifier, Setting, SymbolDefinition, Table, TableAlias, TableAliasColumnDef, TableFactor, TableFunctionArgs, TableIndexHintForClause, TableIndexHintType, TableIndexHints, TableIndexType, TableSample, TableSampleBucket, TableSampleKind, TableSampleMethod, TableSampleModifier, TableSampleQuantity, TableSampleSeed, TableSampleSeedModifier, TableSampleUnit, TableVersion, TableWithJoins, Top, TopQuantity, UpdateTableFromKind, ValueTableMode, Values, WildcardAdditionalOptions, With, WithFill, XmlNamespaceDefinition, XmlPassingArgument, XmlPassingClause, XmlTableColumn, XmlTableColumnOption, }; pub use self::trigger::{ TriggerEvent, TriggerExecBody, TriggerExecBodyType, TriggerObject, TriggerPeriod, TriggerReferencing, TriggerReferencingType, }; pub use self::value::{ escape_double_quote_string, escape_quoted_string, DateTimeField, DollarQuotedString, NormalizationForm, QuoteDelimitedString, TrimWhereField, Value, ValueWithSpan, }; use crate::ast::helpers::key_value_options::KeyValueOptions; use crate::ast::helpers::stmt_data_loading::StageParamsObject; #[cfg(feature = "visitor")] pub use visitor::*; pub use self::data_type::GeometricTypeKind; mod data_type; mod dcl; mod ddl; mod dml; /// Helper modules for building and manipulating AST nodes. pub mod helpers; pub mod table_constraints; pub use table_constraints::{ CheckConstraint, ConstraintUsingIndex, ForeignKeyConstraint, FullTextOrSpatialConstraint, IndexConstraint, PrimaryKeyConstraint, TableConstraint, UniqueConstraint, }; mod operator; mod query; mod spans; pub use spans::Spanned; pub mod comments; mod trigger; mod value; #[cfg(feature = "visitor")] mod visitor; /// Helper used to format a slice using a separator string (e.g., `", "`). pub struct DisplaySeparated<'a, T> where T: fmt::Display, { slice: &'a [T], sep: &'static str, } impl fmt::Display for DisplaySeparated<'_, T> where T: fmt::Display, { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let mut delim = ""; for t in self.slice { f.write_str(delim)?; delim = self.sep; t.fmt(f)?; } Ok(()) } } pub(crate) fn display_separated<'a, T>(slice: &'a [T], sep: &'static str) -> DisplaySeparated<'a, T> where T: fmt::Display, { DisplaySeparated { slice, sep } } pub(crate) fn display_comma_separated(slice: &[T]) -> DisplaySeparated<'_, T> where T: fmt::Display, { DisplaySeparated { slice, sep: ", " } } /// Writes the given statements to the formatter, each ending with /// a semicolon and space separated. fn format_statement_list(f: &mut fmt::Formatter, statements: &[Statement]) -> fmt::Result { write!(f, "{}", display_separated(statements, "; "))?; // We manually insert semicolon for the last statement, // since display_separated doesn't handle that case. write!(f, ";") } /// A item `T` enclosed in a pair of parentheses #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct Parens { /// the opening parenthesis token, i.e. `(` pub opening_token: AttachedToken, /// content enclosed in parentheses pub content: T, /// the closing parenthesis token, i.e. `)` pub closing_token: AttachedToken, } impl Parens { /// Constructor wrapping `content` into `Parens` with an empty span; /// useful for testing purposes. pub fn with_empty_span(content: T) -> Self { Self { opening_token: AttachedToken::empty(), content, closing_token: AttachedToken::empty(), } } } impl Deref for Parens { type Target = T; fn deref(&self) -> &Self::Target { &self.content } } impl DerefMut for Parens { fn deref_mut(&mut self) -> &mut Self::Target { &mut self.content } } /// An identifier, decomposed into its value or character data and the quote style. #[derive(Debug, Clone)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct Ident { /// The value of the identifier without quotes. pub value: String, /// The starting quote if any. Valid quote characters are the single quote, /// double quote, backtick, and opening square bracket. pub quote_style: Option, /// The span of the identifier in the original SQL string. pub span: Span, } impl PartialEq for Ident { fn eq(&self, other: &Self) -> bool { let Ident { value, quote_style, // exhaustiveness check; we ignore spans in comparisons span: _, } = self; value == &other.value && quote_style == &other.quote_style } } impl core::hash::Hash for Ident { fn hash(&self, state: &mut H) { let Ident { value, quote_style, // exhaustiveness check; we ignore spans in hashes span: _, } = self; value.hash(state); quote_style.hash(state); } } impl Eq for Ident {} impl PartialOrd for Ident { fn partial_cmp(&self, other: &Self) -> Option { Some(self.cmp(other)) } } impl Ord for Ident { fn cmp(&self, other: &Self) -> Ordering { let Ident { value, quote_style, // exhaustiveness check; we ignore spans in ordering span: _, } = self; let Ident { value: other_value, quote_style: other_quote_style, // exhaustiveness check; we ignore spans in ordering span: _, } = other; // First compare by value, then by quote_style value .cmp(other_value) .then_with(|| quote_style.cmp(other_quote_style)) } } impl Ident { /// Create a new identifier with the given value and no quotes and an empty span. pub fn new(value: S) -> Self where S: Into, { Ident { value: value.into(), quote_style: None, span: Span::empty(), } } /// Create a new quoted identifier with the given quote and value. This function /// panics if the given quote is not a valid quote character. pub fn with_quote(quote: char, value: S) -> Self where S: Into, { assert!(quote == '\'' || quote == '"' || quote == '`' || quote == '['); Ident { value: value.into(), quote_style: Some(quote), span: Span::empty(), } } /// Create an `Ident` with the given `span` and `value` (unquoted). pub fn with_span(span: Span, value: S) -> Self where S: Into, { Ident { value: value.into(), quote_style: None, span, } } /// Create a quoted `Ident` with the given `quote` and `span`. pub fn with_quote_and_span(quote: char, span: Span, value: S) -> Self where S: Into, { assert!(quote == '\'' || quote == '"' || quote == '`' || quote == '['); Ident { value: value.into(), quote_style: Some(quote), span, } } } impl From<&str> for Ident { fn from(value: &str) -> Self { Ident { value: value.to_string(), quote_style: None, span: Span::empty(), } } } impl fmt::Display for Ident { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self.quote_style { Some(q) if q == '"' || q == '\'' || q == '`' => { let escaped = value::escape_quoted_string(&self.value, q); write!(f, "{q}{escaped}{q}") } Some('[') => write!(f, "[{}]", self.value), None => f.write_str(&self.value), _ => panic!("unexpected quote style"), } } } /// A name of a table, view, custom type, etc., possibly multi-part, i.e. db.schema.obj #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct ObjectName(pub Vec); impl From> for ObjectName { fn from(idents: Vec) -> Self { ObjectName(idents.into_iter().map(ObjectNamePart::Identifier).collect()) } } impl From for ObjectName { fn from(ident: Ident) -> Self { ObjectName(vec![ObjectNamePart::Identifier(ident)]) } } impl fmt::Display for ObjectName { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{}", display_separated(&self.0, ".")) } } /// A single part of an ObjectName #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum ObjectNamePart { /// A single identifier part, e.g. `schema` or `table`. Identifier(Ident), /// A function that returns an identifier (dialect-specific). Function(ObjectNamePartFunction), } impl ObjectNamePart { /// Return the identifier if this is an `Identifier` variant. pub fn as_ident(&self) -> Option<&Ident> { match self { ObjectNamePart::Identifier(ident) => Some(ident), ObjectNamePart::Function(_) => None, } } } impl fmt::Display for ObjectNamePart { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { ObjectNamePart::Identifier(ident) => write!(f, "{ident}"), ObjectNamePart::Function(func) => write!(f, "{func}"), } } } /// An object name part that consists of a function that dynamically /// constructs identifiers. /// /// - [Snowflake](https://docs.snowflake.com/en/sql-reference/identifier-literal) #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct ObjectNamePartFunction { /// The function name that produces the object name part. pub name: Ident, /// Function arguments used to compute the identifier. pub args: Vec, } impl fmt::Display for ObjectNamePartFunction { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{}(", self.name)?; write!(f, "{})", display_comma_separated(&self.args)) } } /// Represents an Array Expression, either /// `ARRAY[..]`, or `[..]` #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct Array { /// The list of expressions between brackets pub elem: Vec, /// `true` for `ARRAY[..]`, `false` for `[..]` pub named: bool, } impl fmt::Display for Array { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "{}[{}]", if self.named { "ARRAY" } else { "" }, display_comma_separated(&self.elem) ) } } /// Represents an INTERVAL expression, roughly in the following format: /// `INTERVAL '' [ [ () ] ] /// [ TO [ () ] ]`, /// e.g. `INTERVAL '123:45.67' MINUTE(3) TO SECOND(2)`. /// /// The parser does not validate the ``, nor does it ensure /// that the `` units >= the units in ``, /// so the user will have to reject intervals like `HOUR TO YEAR`. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct Interval { /// The interval value expression (commonly a string literal). pub value: Box, /// Optional leading time unit (e.g., `HOUR`, `MINUTE`). pub leading_field: Option, /// Optional leading precision for the leading field. pub leading_precision: Option, /// Optional trailing time unit for a range (e.g., `SECOND`). pub last_field: Option, /// The fractional seconds precision, when specified. /// /// See SQL `SECOND(n)` or `SECOND(m, n)` forms. pub fractional_seconds_precision: Option, } impl fmt::Display for Interval { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let value = self.value.as_ref(); match ( &self.leading_field, self.leading_precision, self.fractional_seconds_precision, ) { ( Some(DateTimeField::Second), Some(leading_precision), Some(fractional_seconds_precision), ) => { // When the leading field is SECOND, the parser guarantees that // the last field is None. assert!(self.last_field.is_none()); write!( f, "INTERVAL {value} SECOND ({leading_precision}, {fractional_seconds_precision})" ) } _ => { write!(f, "INTERVAL {value}")?; if let Some(leading_field) = &self.leading_field { write!(f, " {leading_field}")?; } if let Some(leading_precision) = self.leading_precision { write!(f, " ({leading_precision})")?; } if let Some(last_field) = &self.last_field { write!(f, " TO {last_field}")?; } if let Some(fractional_seconds_precision) = self.fractional_seconds_precision { write!(f, " ({fractional_seconds_precision})")?; } Ok(()) } } } } /// A field definition within a struct /// /// [BigQuery]: https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types#struct_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 StructField { /// Optional name of the struct field. pub field_name: Option, /// The field data type. pub field_type: DataType, /// Struct field options (e.g., `OPTIONS(...)` on BigQuery). /// See [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language#column_name_and_column_schema) pub options: Option>, } impl fmt::Display for StructField { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { if let Some(name) = &self.field_name { write!(f, "{name} {}", self.field_type)?; } else { write!(f, "{}", self.field_type)?; } if let Some(options) = &self.options { write!(f, " OPTIONS({})", display_separated(options, ", ")) } else { Ok(()) } } } /// A field definition within a union /// /// [DuckDB]: https://duckdb.org/docs/sql/data_types/union.html #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct UnionField { /// Name of the union field. pub field_name: Ident, /// Type of the union field. pub field_type: DataType, } impl fmt::Display for UnionField { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "{} {}", self.field_name, self.field_type) } } /// A dictionary field within a dictionary. /// /// [DuckDB]: https://duckdb.org/docs/sql/data_types/struct#creating-structs #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct DictionaryField { /// Dictionary key identifier. pub key: Ident, /// Value expression for the dictionary entry. pub value: Box, } impl fmt::Display for DictionaryField { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "{}: {}", self.key, self.value) } } /// Represents a Map expression. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct Map { /// Entries of the map as key/value pairs. pub entries: Vec, } impl Display for Map { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "MAP {{{}}}", display_comma_separated(&self.entries)) } } /// A map field within a map. /// /// [DuckDB]: https://duckdb.org/docs/sql/data_types/map.html#creating-maps #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct MapEntry { /// Key expression of the map entry. pub key: Box, /// Value expression of the map entry. pub value: Box, } impl fmt::Display for MapEntry { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "{}: {}", self.key, self.value) } } /// Options for `CAST` / `TRY_CAST` /// BigQuery: #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum CastFormat { /// A simple cast format specified by a `Value`. Value(ValueWithSpan), /// A cast format with an explicit time zone: `(format, timezone)`. ValueAtTimeZone(ValueWithSpan, ValueWithSpan), } /// An element of a JSON path. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum JsonPathElem { /// Accesses an object field using dot notation, e.g. `obj:foo.bar.baz`. /// /// See . Dot { /// The object key text (without quotes). key: String, /// `true` when the key was quoted in the source. quoted: bool, }, /// Accesses an object field or array element using bracket notation, /// e.g. `obj['foo']`. /// /// See . Bracket { /// The expression used as the bracket key (string or numeric expression). key: Expr, }, /// Access an object field using colon bracket notation /// e.g. `obj:['foo']` /// /// See ColonBracket { /// The expression used as the bracket key (string or numeric expression). key: Expr, }, } /// A JSON path. /// /// See . /// See . #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct JsonPath { /// Sequence of path elements that form the JSON path. pub path: Vec, } impl fmt::Display for JsonPath { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { for (i, elem) in self.path.iter().enumerate() { match elem { JsonPathElem::Dot { key, quoted } => { if i == 0 { write!(f, ":")?; } else { write!(f, ".")?; } if *quoted { write!(f, "\"{}\"", escape_double_quote_string(key))?; } else { write!(f, "{key}")?; } } JsonPathElem::Bracket { key } => { write!(f, "[{key}]")?; } JsonPathElem::ColonBracket { key } => { write!(f, ":[{key}]")?; } } } Ok(()) } } /// The syntax used for in a cast expression. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum CastKind { /// The standard SQL cast syntax, e.g. `CAST( as )` Cast, /// A cast that returns `NULL` on failure, e.g. `TRY_CAST( as )`. /// /// See . /// See . TryCast, /// A cast that returns `NULL` on failure, bigQuery-specific , e.g. `SAFE_CAST( as )`. /// /// See . SafeCast, /// ` :: ` DoubleColon, } /// `MATCH` type for constraint references /// /// See: #[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 ConstraintReferenceMatchKind { /// `MATCH FULL` Full, /// `MATCH PARTIAL` Partial, /// `MATCH SIMPLE` Simple, } impl fmt::Display for ConstraintReferenceMatchKind { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { Self::Full => write!(f, "MATCH FULL"), Self::Partial => write!(f, "MATCH PARTIAL"), Self::Simple => write!(f, "MATCH SIMPLE"), } } } /// `EXTRACT` syntax variants. /// /// In Snowflake dialect, the `EXTRACT` expression can support either the `from` syntax /// or the comma syntax. /// /// See #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum ExtractSyntax { /// `EXTRACT( FROM )` From, /// `EXTRACT( , )` Comma, } /// The syntax used in a CEIL or FLOOR expression. /// /// The `CEIL/FLOOR( TO , , ...) AGAINST ( []) /// /// = CompoundIdentifier /// = String literal /// ``` /// [(1)]: https://dev.mysql.com/doc/refman/8.0/en/fulltext-search.html#function_match MatchAgainst { /// `(, , ...)`. columns: Vec, /// ``. match_value: ValueWithSpan, /// `` opt_search_modifier: Option, }, /// An unqualified `*` wildcard token (e.g. `*`). Wildcard(AttachedToken), /// Qualified wildcard, e.g. `alias.*` or `schema.table.*`. /// (Same caveats apply to `QualifiedWildcard` as to `Wildcard`.) QualifiedWildcard(ObjectName, AttachedToken), /// Some dialects support an older syntax for outer joins where columns are /// marked with the `(+)` operator in the WHERE clause, for example: /// /// ```sql /// SELECT t1.c1, t2.c2 FROM t1, t2 WHERE t1.c1 = t2.c2 (+) /// ``` /// /// which is equivalent to /// /// ```sql /// SELECT t1.c1, t2.c2 FROM t1 LEFT OUTER JOIN t2 ON t1.c1 = t2.c2 /// ``` /// /// See . OuterJoin(Box), /// A reference to the prior level in a CONNECT BY clause. Prior(Box), /// A lambda function. /// /// Syntax: /// ```plaintext /// param -> expr | (param1, ...) -> expr /// ``` /// /// [ClickHouse](https://clickhouse.com/docs/en/sql-reference/functions#higher-order-functions---operator-and-lambdaparams-expr-function) /// [Databricks](https://docs.databricks.com/en/sql/language-manual/sql-ref-lambda-functions.html) /// [DuckDB](https://duckdb.org/docs/stable/sql/functions/lambda) Lambda(LambdaFunction), /// Checks membership of a value in a JSON array MemberOf(MemberOf), } impl Expr { /// Creates a new [`Expr::Value`] pub fn value(value: impl Into) -> Self { Expr::Value(value.into()) } } /// The contents inside the `[` and `]` in a subscript expression. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum Subscript { /// Accesses the element of the array at the given index. Index { /// The index expression used to access the array element. index: Expr, }, /// Accesses a slice of an array on PostgreSQL, e.g. /// /// ```plaintext /// => select (array[1,2,3,4,5,6])[2:5]; /// ----------- /// {2,3,4,5} /// ``` /// /// The lower and/or upper bound can be omitted to slice from the start or /// end of the array respectively. /// /// See . /// /// Also supports an optional "stride" as the last element (this is not /// supported by postgres), e.g. /// /// ```plaintext /// => select (array[1,2,3,4,5,6])[1:6:2]; /// ----------- /// {1,3,5} /// ``` Slice { /// Optional lower bound for the slice (inclusive). lower_bound: Option, /// Optional upper bound for the slice (inclusive). upper_bound: Option, /// Optional stride for the slice (step size). stride: Option, }, } impl fmt::Display for Subscript { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { Subscript::Index { index } => write!(f, "{index}"), Subscript::Slice { lower_bound, upper_bound, stride, } => { if let Some(lower) = lower_bound { write!(f, "{lower}")?; } write!(f, ":")?; if let Some(upper) = upper_bound { write!(f, "{upper}")?; } if let Some(stride) = stride { write!(f, ":")?; write!(f, "{stride}")?; } Ok(()) } } } } /// An element of a [`Expr::CompoundFieldAccess`]. /// It can be an expression or a subscript. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum AccessExpr { /// Accesses a field using dot notation, e.g. `foo.bar.baz`. Dot(Expr), /// Accesses a field or array element using bracket notation, e.g. `foo['bar']`. Subscript(Subscript), } impl fmt::Display for AccessExpr { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { AccessExpr::Dot(expr) => write!(f, ".{expr}"), AccessExpr::Subscript(subscript) => write!(f, "[{subscript}]"), } } } /// A lambda function. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct LambdaFunction { /// The parameters to the lambda function. pub params: OneOrManyWithParens, /// The body of the lambda function. pub body: Box, /// The syntax style used to write the lambda function. pub syntax: LambdaSyntax, } impl fmt::Display for LambdaFunction { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self.syntax { LambdaSyntax::Arrow => write!(f, "{} -> {}", self.params, self.body), LambdaSyntax::LambdaKeyword => { // For lambda keyword syntax, display params without parentheses // e.g., `lambda x, y : expr` not `lambda (x, y) : expr` write!(f, "lambda ")?; match &self.params { OneOrManyWithParens::One(p) => write!(f, "{p}")?, OneOrManyWithParens::Many(ps) => write!(f, "{}", display_comma_separated(ps))?, }; write!(f, " : {}", self.body) } } } } /// A parameter to a lambda function, optionally with a data 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 LambdaFunctionParameter { /// The name of the parameter pub name: Ident, /// The optional data type of the parameter /// [Snowflake Syntax](https://docs.snowflake.com/en/sql-reference/functions/filter#arguments) pub data_type: Option, } impl fmt::Display for LambdaFunctionParameter { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match &self.data_type { Some(dt) => write!(f, "{} {}", self.name, dt), None => write!(f, "{}", self.name), } } } /// The syntax style for a lambda function. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash, Copy)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum LambdaSyntax { /// Arrow syntax: `param -> expr` or `(param1, param2) -> expr` /// /// /// /// Supported, but deprecated in DuckDB: /// Arrow, /// Lambda keyword syntax: `lambda param : expr` or `lambda param1, param2 : expr` /// /// Recommended in DuckDB: /// LambdaKeyword, } /// Encapsulates the common pattern in SQL where either one unparenthesized item /// such as an identifier or expression is permitted, or multiple of the same /// item in a parenthesized list. For accessing items regardless of the form, /// `OneOrManyWithParens` implements `Deref` and `IntoIterator`, /// so you can call slice methods on it and iterate over items /// # Examples /// Accessing as a slice: /// ``` /// # use sqlparser::ast::OneOrManyWithParens; /// let one = OneOrManyWithParens::One("a"); /// /// assert_eq!(one[0], "a"); /// assert_eq!(one.len(), 1); /// ``` /// Iterating: /// ``` /// # use sqlparser::ast::OneOrManyWithParens; /// let one = OneOrManyWithParens::One("a"); /// let many = OneOrManyWithParens::Many(vec!["a", "b"]); /// /// assert_eq!(one.into_iter().chain(many).collect::>(), vec!["a", "a", "b"] ); /// ``` #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum OneOrManyWithParens { /// A single `T`, unparenthesized. One(T), /// One or more `T`s, parenthesized. Many(Vec), } impl Deref for OneOrManyWithParens { type Target = [T]; fn deref(&self) -> &[T] { match self { OneOrManyWithParens::One(one) => core::slice::from_ref(one), OneOrManyWithParens::Many(many) => many, } } } impl AsRef<[T]> for OneOrManyWithParens { fn as_ref(&self) -> &[T] { self } } impl<'a, T> IntoIterator for &'a OneOrManyWithParens { type Item = &'a T; type IntoIter = core::slice::Iter<'a, T>; fn into_iter(self) -> Self::IntoIter { self.iter() } } /// Owned iterator implementation of `OneOrManyWithParens` #[derive(Debug, Clone)] pub struct OneOrManyWithParensIntoIter { inner: OneOrManyWithParensIntoIterInner, } #[derive(Debug, Clone)] enum OneOrManyWithParensIntoIterInner { One(core::iter::Once), Many( as IntoIterator>::IntoIter), } impl core::iter::FusedIterator for OneOrManyWithParensIntoIter where core::iter::Once: core::iter::FusedIterator, as IntoIterator>::IntoIter: core::iter::FusedIterator, { } impl core::iter::ExactSizeIterator for OneOrManyWithParensIntoIter where core::iter::Once: core::iter::ExactSizeIterator, as IntoIterator>::IntoIter: core::iter::ExactSizeIterator, { } impl core::iter::Iterator for OneOrManyWithParensIntoIter { type Item = T; fn next(&mut self) -> Option { match &mut self.inner { OneOrManyWithParensIntoIterInner::One(one) => one.next(), OneOrManyWithParensIntoIterInner::Many(many) => many.next(), } } fn size_hint(&self) -> (usize, Option) { match &self.inner { OneOrManyWithParensIntoIterInner::One(one) => one.size_hint(), OneOrManyWithParensIntoIterInner::Many(many) => many.size_hint(), } } fn count(self) -> usize where Self: Sized, { match self.inner { OneOrManyWithParensIntoIterInner::One(one) => one.count(), OneOrManyWithParensIntoIterInner::Many(many) => many.count(), } } fn fold(mut self, init: B, f: F) -> B where Self: Sized, F: FnMut(B, Self::Item) -> B, { match &mut self.inner { OneOrManyWithParensIntoIterInner::One(one) => one.fold(init, f), OneOrManyWithParensIntoIterInner::Many(many) => many.fold(init, f), } } } impl core::iter::DoubleEndedIterator for OneOrManyWithParensIntoIter { fn next_back(&mut self) -> Option { match &mut self.inner { OneOrManyWithParensIntoIterInner::One(one) => one.next_back(), OneOrManyWithParensIntoIterInner::Many(many) => many.next_back(), } } } impl IntoIterator for OneOrManyWithParens { type Item = T; type IntoIter = OneOrManyWithParensIntoIter; fn into_iter(self) -> Self::IntoIter { let inner = match self { OneOrManyWithParens::One(one) => { OneOrManyWithParensIntoIterInner::One(core::iter::once(one)) } OneOrManyWithParens::Many(many) => { OneOrManyWithParensIntoIterInner::Many(many.into_iter()) } }; OneOrManyWithParensIntoIter { inner } } } impl fmt::Display for OneOrManyWithParens where T: fmt::Display, { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { OneOrManyWithParens::One(value) => write!(f, "{value}"), OneOrManyWithParens::Many(values) => { write!(f, "({})", display_comma_separated(values)) } } } } impl fmt::Display for CastFormat { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { CastFormat::Value(v) => write!(f, "{v}"), CastFormat::ValueAtTimeZone(v, tz) => write!(f, "{v} AT TIME ZONE {tz}"), } } } impl fmt::Display for Expr { #[cfg_attr(feature = "recursive-protection", recursive::recursive)] fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { Expr::Identifier(s) => write!(f, "{s}"), Expr::Wildcard(_) => f.write_str("*"), Expr::QualifiedWildcard(prefix, _) => write!(f, "{prefix}.*"), Expr::CompoundIdentifier(s) => write!(f, "{}", display_separated(s, ".")), Expr::CompoundFieldAccess { root, access_chain } => { write!(f, "{root}")?; for field in access_chain { write!(f, "{field}")?; } Ok(()) } Expr::IsTrue(ast) => write!(f, "{ast} IS TRUE"), Expr::IsNotTrue(ast) => write!(f, "{ast} IS NOT TRUE"), Expr::IsFalse(ast) => write!(f, "{ast} IS FALSE"), Expr::IsNotFalse(ast) => write!(f, "{ast} IS NOT FALSE"), Expr::IsNull(ast) => write!(f, "{ast} IS NULL"), Expr::IsNotNull(ast) => write!(f, "{ast} IS NOT NULL"), Expr::IsUnknown(ast) => write!(f, "{ast} IS UNKNOWN"), Expr::IsNotUnknown(ast) => write!(f, "{ast} IS NOT UNKNOWN"), Expr::InList { expr, list, negated, } => write!( f, "{} {}IN ({})", expr, if *negated { "NOT " } else { "" }, display_comma_separated(list) ), Expr::InSubquery { expr, subquery, negated, } => write!( f, "{} {}IN ({})", expr, if *negated { "NOT " } else { "" }, subquery ), Expr::InUnnest { expr, array_expr, negated, } => write!( f, "{} {}IN UNNEST({})", expr, if *negated { "NOT " } else { "" }, array_expr ), Expr::Between { expr, negated, low, high, } => write!( f, "{} {}BETWEEN {} AND {}", expr, if *negated { "NOT " } else { "" }, low, high ), Expr::BinaryOp { left, op, right } => write!(f, "{left} {op} {right}"), Expr::Like { negated, expr, pattern, escape_char, any, } => match escape_char { Some(ch) => write!( f, "{} {}LIKE {}{} ESCAPE {}", expr, if *negated { "NOT " } else { "" }, if *any { "ANY " } else { "" }, pattern, ch ), _ => write!( f, "{} {}LIKE {}{}", expr, if *negated { "NOT " } else { "" }, if *any { "ANY " } else { "" }, pattern ), }, Expr::ILike { negated, expr, pattern, escape_char, any, } => match escape_char { Some(ch) => write!( f, "{} {}ILIKE {}{} ESCAPE {}", expr, if *negated { "NOT " } else { "" }, if *any { "ANY" } else { "" }, pattern, ch ), _ => write!( f, "{} {}ILIKE {}{}", expr, if *negated { "NOT " } else { "" }, if *any { "ANY " } else { "" }, pattern ), }, Expr::RLike { negated, expr, pattern, regexp, } => write!( f, "{} {}{} {}", expr, if *negated { "NOT " } else { "" }, if *regexp { "REGEXP" } else { "RLIKE" }, pattern ), Expr::IsNormalized { expr, form, negated, } => { let not_ = if *negated { "NOT " } else { "" }; if form.is_none() { write!(f, "{expr} IS {not_}NORMALIZED") } else { write!( f, "{} IS {}{} NORMALIZED", expr, not_, form.as_ref().unwrap() ) } } Expr::SimilarTo { negated, expr, pattern, escape_char, } => match escape_char { Some(ch) => write!( f, "{} {}SIMILAR TO {} ESCAPE {}", expr, if *negated { "NOT " } else { "" }, pattern, ch ), _ => write!( f, "{} {}SIMILAR TO {}", expr, if *negated { "NOT " } else { "" }, pattern ), }, Expr::AnyOp { left, compare_op, right, is_some, } => { let add_parens = !matches!(right.as_ref(), Expr::Subquery(_)); write!( f, "{left} {compare_op} {}{}{right}{}", if *is_some { "SOME" } else { "ANY" }, if add_parens { "(" } else { "" }, if add_parens { ")" } else { "" }, ) } Expr::AllOp { left, compare_op, right, } => { let add_parens = !matches!(right.as_ref(), Expr::Subquery(_)); write!( f, "{left} {compare_op} ALL{}{right}{}", if add_parens { "(" } else { "" }, if add_parens { ")" } else { "" }, ) } Expr::UnaryOp { op, expr } => { if op == &UnaryOperator::PGPostfixFactorial { write!(f, "{expr}{op}") } else if matches!( op, UnaryOperator::Not | UnaryOperator::Hash | UnaryOperator::AtDashAt | UnaryOperator::DoubleAt | UnaryOperator::QuestionDash | UnaryOperator::QuestionPipe ) { write!(f, "{op} {expr}") } else { write!(f, "{op}{expr}") } } Expr::Convert { is_try, expr, target_before_value, data_type, charset, styles, } => { write!(f, "{}CONVERT(", if *is_try { "TRY_" } else { "" })?; if let Some(data_type) = data_type { if let Some(charset) = charset { write!(f, "{expr}, {data_type} CHARACTER SET {charset}") } else if *target_before_value { write!(f, "{data_type}, {expr}") } else { write!(f, "{expr}, {data_type}") } } else if let Some(charset) = charset { write!(f, "{expr} USING {charset}") } else { write!(f, "{expr}") // This should never happen }?; if !styles.is_empty() { write!(f, ", {}", display_comma_separated(styles))?; } write!(f, ")") } Expr::Cast { kind, expr, data_type, array, format, } => match kind { CastKind::Cast => { write!(f, "CAST({expr} AS {data_type}")?; if *array { write!(f, " ARRAY")?; } if let Some(format) = format { write!(f, " FORMAT {format}")?; } write!(f, ")") } CastKind::TryCast => { if let Some(format) = format { write!(f, "TRY_CAST({expr} AS {data_type} FORMAT {format})") } else { write!(f, "TRY_CAST({expr} AS {data_type})") } } CastKind::SafeCast => { if let Some(format) = format { write!(f, "SAFE_CAST({expr} AS {data_type} FORMAT {format})") } else { write!(f, "SAFE_CAST({expr} AS {data_type})") } } CastKind::DoubleColon => { write!(f, "{expr}::{data_type}") } }, Expr::Extract { field, syntax, expr, } => match syntax { ExtractSyntax::From => write!(f, "EXTRACT({field} FROM {expr})"), ExtractSyntax::Comma => write!(f, "EXTRACT({field}, {expr})"), }, Expr::Ceil { expr, field } => match field { CeilFloorKind::DateTimeField(DateTimeField::NoDateTime) => { write!(f, "CEIL({expr})") } CeilFloorKind::DateTimeField(dt_field) => write!(f, "CEIL({expr} TO {dt_field})"), CeilFloorKind::Scale(s) => write!(f, "CEIL({expr}, {s})"), }, Expr::Floor { expr, field } => match field { CeilFloorKind::DateTimeField(DateTimeField::NoDateTime) => { write!(f, "FLOOR({expr})") } CeilFloorKind::DateTimeField(dt_field) => write!(f, "FLOOR({expr} TO {dt_field})"), CeilFloorKind::Scale(s) => write!(f, "FLOOR({expr}, {s})"), }, Expr::Position { expr, r#in } => write!(f, "POSITION({expr} IN {in})"), Expr::Collate { expr, collation } => write!(f, "{expr} COLLATE {collation}"), Expr::Nested(ast) => write!(f, "({ast})"), Expr::Value(v) => write!(f, "{v}"), Expr::Prefixed { prefix, value } => write!(f, "{prefix} {value}"), Expr::TypedString(ts) => ts.fmt(f), Expr::Function(fun) => fun.fmt(f), Expr::Case { case_token: _, end_token: _, operand, conditions, else_result, } => { f.write_str("CASE")?; if let Some(operand) = operand { f.write_str(" ")?; operand.fmt(f)?; } for when in conditions { SpaceOrNewline.fmt(f)?; Indent(when).fmt(f)?; } if let Some(else_result) = else_result { SpaceOrNewline.fmt(f)?; Indent("ELSE").fmt(f)?; SpaceOrNewline.fmt(f)?; Indent(Indent(else_result)).fmt(f)?; } SpaceOrNewline.fmt(f)?; f.write_str("END") } Expr::Exists { subquery, negated } => write!( f, "{}EXISTS ({})", if *negated { "NOT " } else { "" }, subquery ), Expr::Subquery(s) => write!(f, "({s})"), Expr::GroupingSets(sets) => { write!(f, "GROUPING SETS (")?; let mut sep = ""; for set in sets { write!(f, "{sep}")?; sep = ", "; write!(f, "({})", display_comma_separated(set))?; } write!(f, ")") } Expr::Cube(sets) => { write!(f, "CUBE (")?; let mut sep = ""; for set in sets { write!(f, "{sep}")?; sep = ", "; if set.len() == 1 { write!(f, "{}", set[0])?; } else { write!(f, "({})", display_comma_separated(set))?; } } write!(f, ")") } Expr::Rollup(sets) => { write!(f, "ROLLUP (")?; let mut sep = ""; for set in sets { write!(f, "{sep}")?; sep = ", "; if set.len() == 1 { write!(f, "{}", set[0])?; } else { write!(f, "({})", display_comma_separated(set))?; } } write!(f, ")") } Expr::Substring { expr, substring_from, substring_for, special, shorthand, } => { f.write_str("SUBSTR")?; if !*shorthand { f.write_str("ING")?; } write!(f, "({expr}")?; if let Some(from_part) = substring_from { if *special { write!(f, ", {from_part}")?; } else { write!(f, " FROM {from_part}")?; } } if let Some(for_part) = substring_for { if *special { write!(f, ", {for_part}")?; } else { write!(f, " FOR {for_part}")?; } } write!(f, ")") } Expr::Overlay { expr, overlay_what, overlay_from, overlay_for, } => { write!( f, "OVERLAY({expr} PLACING {overlay_what} FROM {overlay_from}" )?; if let Some(for_part) = overlay_for { write!(f, " FOR {for_part}")?; } write!(f, ")") } Expr::IsDistinctFrom(a, b) => write!(f, "{a} IS DISTINCT FROM {b}"), Expr::IsNotDistinctFrom(a, b) => write!(f, "{a} IS NOT DISTINCT FROM {b}"), Expr::Trim { expr, trim_where, trim_what, trim_characters, } => { write!(f, "TRIM(")?; if let Some(ident) = trim_where { write!(f, "{ident} ")?; } if let Some(trim_char) = trim_what { write!(f, "{trim_char} FROM {expr}")?; } else { write!(f, "{expr}")?; } if let Some(characters) = trim_characters { write!(f, ", {}", display_comma_separated(characters))?; } write!(f, ")") } Expr::Tuple(exprs) => { write!(f, "({})", display_comma_separated(exprs)) } Expr::Struct { values, fields } => { if !fields.is_empty() { write!( f, "STRUCT<{}>({})", display_comma_separated(fields), display_comma_separated(values) ) } else { write!(f, "STRUCT({})", display_comma_separated(values)) } } Expr::Named { expr, name } => { write!(f, "{expr} AS {name}") } Expr::Dictionary(fields) => { write!(f, "{{{}}}", display_comma_separated(fields)) } Expr::Map(map) => { write!(f, "{map}") } Expr::Array(set) => { write!(f, "{set}") } Expr::JsonAccess { value, path } => { write!(f, "{value}{path}") } Expr::AtTimeZone { timestamp, time_zone, } => { write!(f, "{timestamp} AT TIME ZONE {time_zone}") } Expr::Interval(interval) => { write!(f, "{interval}") } Expr::MatchAgainst { columns, match_value: match_expr, opt_search_modifier, } => { write!(f, "MATCH ({}) AGAINST ", display_comma_separated(columns),)?; if let Some(search_modifier) = opt_search_modifier { write!(f, "({match_expr} {search_modifier})")?; } else { write!(f, "({match_expr})")?; } Ok(()) } Expr::OuterJoin(expr) => { write!(f, "{expr} (+)") } Expr::Prior(expr) => write!(f, "PRIOR {expr}"), Expr::Lambda(lambda) => write!(f, "{lambda}"), Expr::MemberOf(member_of) => write!(f, "{member_of}"), } } } /// The type of a window used in `OVER` clauses. /// /// A window can be either an inline specification (`WindowSpec`) or a /// reference to a previously defined named window. /// /// - `WindowSpec(WindowSpec)`: An inline window specification, e.g. /// `OVER (PARTITION BY ... ORDER BY ...)`. /// - `NamedWindow(Ident)`: A reference to a named window declared elsewhere. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum WindowType { /// An inline window specification. WindowSpec(WindowSpec), /// A reference to a previously defined named window. NamedWindow(Ident), } impl Display for WindowType { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { WindowType::WindowSpec(spec) => { f.write_str("(")?; NewLine.fmt(f)?; Indent(spec).fmt(f)?; NewLine.fmt(f)?; f.write_str(")") } WindowType::NamedWindow(name) => name.fmt(f), } } } /// A window specification (i.e. `OVER ([window_name] PARTITION BY .. ORDER BY .. etc.)`) #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct WindowSpec { /// Optional window name. /// /// You can find it at least in [MySQL][1], [BigQuery][2], [PostgreSQL][3] /// /// [1]: https://dev.mysql.com/doc/refman/8.0/en/window-functions-named-windows.html /// [2]: https://cloud.google.com/bigquery/docs/reference/standard-sql/window-function-calls /// [3]: https://www.postgresql.org/docs/current/sql-expressions.html#SYNTAX-WINDOW-FUNCTIONS pub window_name: Option, /// `OVER (PARTITION BY ...)` pub partition_by: Vec, /// `OVER (ORDER BY ...)` pub order_by: Vec, /// `OVER (window frame)` pub window_frame: Option, } impl fmt::Display for WindowSpec { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let mut is_first = true; if let Some(window_name) = &self.window_name { if !is_first { SpaceOrNewline.fmt(f)?; } is_first = false; write!(f, "{window_name}")?; } if !self.partition_by.is_empty() { if !is_first { SpaceOrNewline.fmt(f)?; } is_first = false; write!( f, "PARTITION BY {}", display_comma_separated(&self.partition_by) )?; } if !self.order_by.is_empty() { if !is_first { SpaceOrNewline.fmt(f)?; } is_first = false; write!(f, "ORDER BY {}", display_comma_separated(&self.order_by))?; } if let Some(window_frame) = &self.window_frame { if !is_first { SpaceOrNewline.fmt(f)?; } if let Some(end_bound) = &window_frame.end_bound { write!( f, "{} BETWEEN {} AND {}", window_frame.units, window_frame.start_bound, end_bound )?; } else { write!(f, "{} {}", window_frame.units, window_frame.start_bound)?; } } Ok(()) } } /// Specifies the data processed by a window function, e.g. /// `RANGE UNBOUNDED PRECEDING` or `ROWS BETWEEN 5 PRECEDING AND CURRENT ROW`. /// /// Note: The parser does not validate the specified bounds; the caller should /// reject invalid bounds like `ROWS UNBOUNDED FOLLOWING` before execution. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct WindowFrame { /// Units for the frame (e.g. `ROWS`, `RANGE`, `GROUPS`). pub units: WindowFrameUnits, /// The start bound of the window frame. pub start_bound: WindowFrameBound, /// The right bound of the `BETWEEN .. AND` clause. The end bound of `None` /// indicates the shorthand form (e.g. `ROWS 1 PRECEDING`), which must /// behave the same as `end_bound = WindowFrameBound::CurrentRow`. pub end_bound: Option, // TBD: EXCLUDE } impl Default for WindowFrame { /// Returns default value for window frame /// /// See [this page](https://www.sqlite.org/windowfunctions.html#frame_specifications) for more details. fn default() -> Self { Self { units: WindowFrameUnits::Range, start_bound: WindowFrameBound::Preceding(None), end_bound: None, } } } #[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Units used to describe the window frame scope. pub enum WindowFrameUnits { /// `ROWS` unit. Rows, /// `RANGE` unit. Range, /// `GROUPS` unit. Groups, } impl fmt::Display for WindowFrameUnits { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str(match self { WindowFrameUnits::Rows => "ROWS", WindowFrameUnits::Range => "RANGE", WindowFrameUnits::Groups => "GROUPS", }) } } /// Specifies Ignore / Respect NULL within window functions. /// For example /// `FIRST_VALUE(column2) IGNORE NULLS OVER (PARTITION BY column1)` #[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// How NULL values are treated in certain window functions. pub enum NullTreatment { /// Ignore NULL values (e.g. `IGNORE NULLS`). IgnoreNulls, /// Respect NULL values (e.g. `RESPECT NULLS`). RespectNulls, } impl fmt::Display for NullTreatment { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str(match self { NullTreatment::IgnoreNulls => "IGNORE NULLS", NullTreatment::RespectNulls => "RESPECT NULLS", }) } } /// Specifies [WindowFrame]'s `start_bound` and `end_bound` #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum WindowFrameBound { /// `CURRENT ROW` CurrentRow, /// ` PRECEDING` or `UNBOUNDED PRECEDING` Preceding(Option>), /// ` FOLLOWING` or `UNBOUNDED FOLLOWING`. Following(Option>), } impl fmt::Display for WindowFrameBound { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { WindowFrameBound::CurrentRow => f.write_str("CURRENT ROW"), WindowFrameBound::Preceding(None) => f.write_str("UNBOUNDED PRECEDING"), WindowFrameBound::Following(None) => f.write_str("UNBOUNDED FOLLOWING"), WindowFrameBound::Preceding(Some(n)) => write!(f, "{n} PRECEDING"), WindowFrameBound::Following(Some(n)) => write!(f, "{n} FOLLOWING"), } } } #[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Indicates partition operation type for partition management statements. pub enum AddDropSync { /// Add partitions. ADD, /// Drop partitions. DROP, /// Sync partitions. SYNC, } impl fmt::Display for AddDropSync { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { AddDropSync::SYNC => f.write_str("SYNC PARTITIONS"), AddDropSync::DROP => f.write_str("DROP PARTITIONS"), AddDropSync::ADD => f.write_str("ADD PARTITIONS"), } } } #[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Object kinds supported by `SHOW CREATE` statements. pub enum ShowCreateObject { /// An event object for `SHOW CREATE EVENT`. Event, /// A function object for `SHOW CREATE FUNCTION`. Function, /// A procedure object for `SHOW CREATE PROCEDURE`. Procedure, /// A table object for `SHOW CREATE TABLE`. Table, /// A trigger object for `SHOW CREATE TRIGGER`. Trigger, /// A view object for `SHOW CREATE VIEW`. View, } impl fmt::Display for ShowCreateObject { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { ShowCreateObject::Event => f.write_str("EVENT"), ShowCreateObject::Function => f.write_str("FUNCTION"), ShowCreateObject::Procedure => f.write_str("PROCEDURE"), ShowCreateObject::Table => f.write_str("TABLE"), ShowCreateObject::Trigger => f.write_str("TRIGGER"), ShowCreateObject::View => f.write_str("VIEW"), } } } #[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Objects that can be targeted by a `COMMENT` statement. pub enum CommentObject { /// A collation. Collation, /// A table column. Column, /// A database. Database, /// A domain. Domain, /// An extension. Extension, /// A function. Function, /// An index. Index, /// A materialized view. MaterializedView, /// A procedure. Procedure, /// A role. Role, /// A schema. Schema, /// A sequence. Sequence, /// A table. Table, /// A type. Type, /// A user. User, /// A view. View, } impl fmt::Display for CommentObject { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { CommentObject::Collation => f.write_str("COLLATION"), CommentObject::Column => f.write_str("COLUMN"), CommentObject::Database => f.write_str("DATABASE"), CommentObject::Domain => f.write_str("DOMAIN"), CommentObject::Extension => f.write_str("EXTENSION"), CommentObject::Function => f.write_str("FUNCTION"), CommentObject::Index => f.write_str("INDEX"), CommentObject::MaterializedView => f.write_str("MATERIALIZED VIEW"), CommentObject::Procedure => f.write_str("PROCEDURE"), CommentObject::Role => f.write_str("ROLE"), CommentObject::Schema => f.write_str("SCHEMA"), CommentObject::Sequence => f.write_str("SEQUENCE"), CommentObject::Table => f.write_str("TABLE"), CommentObject::Type => f.write_str("TYPE"), CommentObject::User => f.write_str("USER"), CommentObject::View => f.write_str("VIEW"), } } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Password specification variants used in user-related statements. pub enum Password { /// A concrete password expression. Password(Expr), /// Represents a `NULL` password. NullPassword, } /// A `CASE` statement. /// /// Examples: /// ```sql /// CASE /// WHEN EXISTS(SELECT 1) /// THEN SELECT 1 FROM T; /// WHEN EXISTS(SELECT 2) /// THEN SELECT 1 FROM U; /// ELSE /// SELECT 1 FROM V; /// END CASE; /// ``` /// /// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/procedural-language#case_search_expression) /// [Snowflake](https://docs.snowflake.com/en/sql-reference/snowflake-scripting/case) #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct CaseStatement { /// The `CASE` token that starts the statement. pub case_token: AttachedToken, /// Optional expression to match against in `CASE ... WHEN`. pub match_expr: Option, /// The `WHEN ... THEN` blocks of the `CASE` statement. pub when_blocks: Vec, /// Optional `ELSE` block for the `CASE` statement. pub else_block: Option, /// The last token of the statement (`END` or `CASE`). pub end_case_token: AttachedToken, } impl fmt::Display for CaseStatement { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let CaseStatement { case_token: _, match_expr, when_blocks, else_block, end_case_token: AttachedToken(end), } = self; write!(f, "CASE")?; if let Some(expr) = match_expr { write!(f, " {expr}")?; } if !when_blocks.is_empty() { write!(f, " {}", display_separated(when_blocks, " "))?; } if let Some(else_block) = else_block { write!(f, " {else_block}")?; } write!(f, " END")?; if let Token::Word(w) = &end.token { if w.keyword == Keyword::CASE { write!(f, " CASE")?; } } Ok(()) } } /// An `IF` statement. /// /// Example (BigQuery or Snowflake): /// ```sql /// IF TRUE THEN /// SELECT 1; /// SELECT 2; /// ELSEIF TRUE THEN /// SELECT 3; /// ELSE /// SELECT 4; /// END IF /// ``` /// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/procedural-language#if) /// [Snowflake](https://docs.snowflake.com/en/sql-reference/snowflake-scripting/if) /// /// Example (MSSQL): /// ```sql /// IF 1=1 SELECT 1 ELSE SELECT 2 /// ``` /// [MSSQL](https://learn.microsoft.com/en-us/sql/t-sql/language-elements/if-else-transact-sql?view=sql-server-ver16) #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct IfStatement { /// The initial `IF` block containing the condition and statements. pub if_block: ConditionalStatementBlock, /// Additional `ELSEIF` blocks. pub elseif_blocks: Vec, /// Optional `ELSE` block. pub else_block: Option, /// Optional trailing `END` token for the `IF` statement. pub end_token: Option, } impl fmt::Display for IfStatement { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let IfStatement { if_block, elseif_blocks, else_block, end_token, } = self; write!(f, "{if_block}")?; for elseif_block in elseif_blocks { write!(f, " {elseif_block}")?; } if let Some(else_block) = else_block { write!(f, " {else_block}")?; } if let Some(AttachedToken(end_token)) = end_token { write!(f, " END {end_token}")?; } Ok(()) } } /// A `WHILE` statement. /// /// Example: /// ```sql /// WHILE @@FETCH_STATUS = 0 /// BEGIN /// FETCH NEXT FROM c1 INTO @var1, @var2; /// END /// ``` /// /// [MsSql](https://learn.microsoft.com/en-us/sql/t-sql/language-elements/while-transact-sql) #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct WhileStatement { /// Block executed while the condition holds. pub while_block: ConditionalStatementBlock, } impl fmt::Display for WhileStatement { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let WhileStatement { while_block } = self; write!(f, "{while_block}")?; Ok(()) } } /// A block within a [Statement::Case] or [Statement::If] or [Statement::While]-like statement /// /// Example 1: /// ```sql /// WHEN EXISTS(SELECT 1) THEN SELECT 1; /// ``` /// /// Example 2: /// ```sql /// IF TRUE THEN SELECT 1; SELECT 2; /// ``` /// /// Example 3: /// ```sql /// ELSE SELECT 1; SELECT 2; /// ``` /// /// Example 4: /// ```sql /// WHILE @@FETCH_STATUS = 0 /// BEGIN /// FETCH NEXT FROM c1 INTO @var1, @var2; /// END /// ``` #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct ConditionalStatementBlock { /// Token representing the start of the block (e.g., WHEN/IF/WHILE). pub start_token: AttachedToken, /// Optional condition expression for the block. pub condition: Option, /// Optional token for the `THEN` keyword. pub then_token: Option, /// The statements contained in this conditional block. pub conditional_statements: ConditionalStatements, } impl ConditionalStatementBlock { /// Get the statements in this conditional block. pub fn statements(&self) -> &Vec { self.conditional_statements.statements() } } impl fmt::Display for ConditionalStatementBlock { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let ConditionalStatementBlock { start_token: AttachedToken(start_token), condition, then_token, conditional_statements, } = self; write!(f, "{start_token}")?; if let Some(condition) = condition { write!(f, " {condition}")?; } if then_token.is_some() { write!(f, " THEN")?; } if !conditional_statements.statements().is_empty() { write!(f, " {conditional_statements}")?; } Ok(()) } } /// A list of statements in a [ConditionalStatementBlock]. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Statements used inside conditional blocks (`IF`, `WHEN`, `WHILE`). pub enum ConditionalStatements { /// Simple sequence of statements (no `BEGIN`/`END`). Sequence { /// The statements in the sequence. statements: Vec, }, /// Block enclosed by `BEGIN` and `END`. BeginEnd(BeginEndStatements), } impl ConditionalStatements { /// Get the statements in this conditional statements block. pub fn statements(&self) -> &Vec { match self { ConditionalStatements::Sequence { statements } => statements, ConditionalStatements::BeginEnd(bes) => &bes.statements, } } } impl fmt::Display for ConditionalStatements { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { ConditionalStatements::Sequence { statements } => { if !statements.is_empty() { format_statement_list(f, statements)?; } Ok(()) } ConditionalStatements::BeginEnd(bes) => write!(f, "{bes}"), } } } /// Represents a list of statements enclosed within `BEGIN` and `END` keywords. /// Example: /// ```sql /// BEGIN /// SELECT 1; /// SELECT 2; /// END /// ``` #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct BeginEndStatements { /// Token representing the `BEGIN` keyword (may include span info). pub begin_token: AttachedToken, /// Statements contained within the block. pub statements: Vec, /// Token representing the `END` keyword (may include span info). pub end_token: AttachedToken, } impl fmt::Display for BeginEndStatements { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let BeginEndStatements { begin_token: AttachedToken(begin_token), statements, end_token: AttachedToken(end_token), } = self; if begin_token.token != Token::EOF { write!(f, "{begin_token} ")?; } if !statements.is_empty() { format_statement_list(f, statements)?; } if end_token.token != Token::EOF { write!(f, " {end_token}")?; } Ok(()) } } /// A `RAISE` statement. /// /// Examples: /// ```sql /// RAISE USING MESSAGE = 'error'; /// /// RAISE myerror; /// ``` /// /// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/procedural-language#raise) /// [Snowflake](https://docs.snowflake.com/en/sql-reference/snowflake-scripting/raise) #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct RaiseStatement { /// Optional value provided to the RAISE statement. pub value: Option, } impl fmt::Display for RaiseStatement { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { let RaiseStatement { value } = self; write!(f, "RAISE")?; if let Some(value) = value { write!(f, " {value}")?; } Ok(()) } } /// Represents the error value of a [RaiseStatement]. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum RaiseStatementValue { /// `RAISE USING MESSAGE = 'error'` UsingMessage(Expr), /// `RAISE myerror` Expr(Expr), } impl fmt::Display for RaiseStatementValue { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { RaiseStatementValue::Expr(expr) => write!(f, "{expr}"), RaiseStatementValue::UsingMessage(expr) => write!(f, "USING MESSAGE = {expr}"), } } } /// A MSSQL `THROW` statement. /// /// ```sql /// THROW [ error_number, message, state ] /// ``` /// /// [MSSQL](https://learn.microsoft.com/en-us/sql/t-sql/language-elements/throw-transact-sql) #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct ThrowStatement { /// Error number expression. pub error_number: Option>, /// Error message expression. pub message: Option>, /// State expression. pub state: Option>, } impl fmt::Display for ThrowStatement { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { let ThrowStatement { error_number, message, state, } = self; write!(f, "THROW")?; if let (Some(error_number), Some(message), Some(state)) = (error_number, message, state) { write!(f, " {error_number}, {message}, {state}")?; } Ok(()) } } /// Represents an expression assignment within a variable `DECLARE` statement. /// /// Examples: /// ```sql /// DECLARE variable_name := 42 /// DECLARE variable_name DEFAULT 42 /// ``` #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum DeclareAssignment { /// Plain expression specified. Expr(Box), /// Expression assigned via the `DEFAULT` keyword Default(Box), /// Expression assigned via the `:=` syntax /// /// Example: /// ```sql /// DECLARE variable_name := 42; /// ``` DuckAssignment(Box), /// Expression via the `FOR` keyword /// /// Example: /// ```sql /// DECLARE c1 CURSOR FOR res /// ``` For(Box), /// Expression via the `=` syntax. /// /// Example: /// ```sql /// DECLARE @variable AS INT = 100 /// ``` MsSqlAssignment(Box), } impl fmt::Display for DeclareAssignment { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { DeclareAssignment::Expr(expr) => { write!(f, "{expr}") } DeclareAssignment::Default(expr) => { write!(f, "DEFAULT {expr}") } DeclareAssignment::DuckAssignment(expr) => { write!(f, ":= {expr}") } DeclareAssignment::MsSqlAssignment(expr) => { write!(f, "= {expr}") } DeclareAssignment::For(expr) => { write!(f, "FOR {expr}") } } } } /// Represents the type of a `DECLARE` statement. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum DeclareType { /// Cursor variable type. e.g. [Snowflake] [PostgreSQL] [MsSql] /// /// [Snowflake]: https://docs.snowflake.com/en/developer-guide/snowflake-scripting/cursors#declaring-a-cursor /// [PostgreSQL]: https://www.postgresql.org/docs/current/plpgsql-cursors.html /// [MsSql]: https://learn.microsoft.com/en-us/sql/t-sql/language-elements/declare-cursor-transact-sql Cursor, /// Result set variable type. [Snowflake] /// /// Syntax: /// ```text /// RESULTSET [ { DEFAULT | := } ( ) ] ; /// ``` /// [Snowflake]: https://docs.snowflake.com/en/sql-reference/snowflake-scripting/declare#resultset-declaration-syntax ResultSet, /// Exception declaration syntax. [Snowflake] /// /// Syntax: /// ```text /// EXCEPTION [ ( , '' ) ] ; /// ``` /// [Snowflake]: https://docs.snowflake.com/en/sql-reference/snowflake-scripting/declare#exception-declaration-syntax Exception, } impl fmt::Display for DeclareType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { DeclareType::Cursor => { write!(f, "CURSOR") } DeclareType::ResultSet => { write!(f, "RESULTSET") } DeclareType::Exception => { write!(f, "EXCEPTION") } } } } /// A `DECLARE` statement. /// [PostgreSQL] [Snowflake] [BigQuery] /// /// Examples: /// ```sql /// DECLARE variable_name := 42 /// DECLARE liahona CURSOR FOR SELECT * FROM films; /// ``` /// /// [PostgreSQL]: https://www.postgresql.org/docs/current/sql-declare.html /// [Snowflake]: https://docs.snowflake.com/en/sql-reference/snowflake-scripting/declare /// [BigQuery]: https://cloud.google.com/bigquery/docs/reference/standard-sql/procedural-language#declare #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct Declare { /// The name(s) being declared. /// Example: `DECLARE a, b, c DEFAULT 42; pub names: Vec, /// Data-type assigned to the declared variable. /// Example: `DECLARE x INT64 DEFAULT 42; pub data_type: Option, /// Expression being assigned to the declared variable. pub assignment: Option, /// Represents the type of the declared variable. pub declare_type: Option, /// Causes the cursor to return data in binary rather than in text format. pub binary: Option, /// None = Not specified /// Some(true) = INSENSITIVE /// Some(false) = ASENSITIVE pub sensitive: Option, /// None = Not specified /// Some(true) = SCROLL /// Some(false) = NO SCROLL pub scroll: Option, /// None = Not specified /// Some(true) = WITH HOLD, specifies that the cursor can continue to be used after the transaction that created it successfully commits /// Some(false) = WITHOUT HOLD, specifies that the cursor cannot be used outside of the transaction that created it pub hold: Option, /// `FOR ` clause in a CURSOR declaration. pub for_query: Option>, } impl fmt::Display for Declare { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let Declare { names, data_type, assignment, declare_type, binary, sensitive, scroll, hold, for_query, } = self; write!(f, "{}", display_comma_separated(names))?; if let Some(true) = binary { write!(f, " BINARY")?; } if let Some(sensitive) = sensitive { if *sensitive { write!(f, " INSENSITIVE")?; } else { write!(f, " ASENSITIVE")?; } } if let Some(scroll) = scroll { if *scroll { write!(f, " SCROLL")?; } else { write!(f, " NO SCROLL")?; } } if let Some(declare_type) = declare_type { write!(f, " {declare_type}")?; } if let Some(hold) = hold { if *hold { write!(f, " WITH HOLD")?; } else { write!(f, " WITHOUT HOLD")?; } } if let Some(query) = for_query { write!(f, " FOR {query}")?; } if let Some(data_type) = data_type { write!(f, " {data_type}")?; } if let Some(expr) = assignment { write!(f, " {expr}")?; } Ok(()) } } /// Sql options of a `CREATE TABLE` statement. #[derive(Debug, Default, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Options allowed within a `CREATE TABLE` statement. pub enum CreateTableOptions { /// No options specified. #[default] None, /// Options specified using the `WITH` keyword, e.g. `WITH (k = v)`. With(Vec), /// Options specified using the `OPTIONS(...)` clause. Options(Vec), /// Plain space-separated options. Plain(Vec), /// Table properties (e.g., TBLPROPERTIES / storage properties). TableProperties(Vec), } impl fmt::Display for CreateTableOptions { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { CreateTableOptions::With(with_options) => { write!(f, "WITH ({})", display_comma_separated(with_options)) } CreateTableOptions::Options(options) => { write!(f, "OPTIONS({})", display_comma_separated(options)) } CreateTableOptions::TableProperties(options) => { write!(f, "TBLPROPERTIES ({})", display_comma_separated(options)) } CreateTableOptions::Plain(options) => { write!(f, "{}", display_separated(options, " ")) } CreateTableOptions::None => Ok(()), } } } /// A `FROM` clause within a `DELETE` statement. /// /// Syntax /// ```sql /// [FROM] table /// ``` #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum FromTable { /// An explicit `FROM` keyword was specified. WithFromKeyword(Vec), /// BigQuery: `FROM` keyword was omitted. /// WithoutKeyword(Vec), } impl Display for FromTable { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { FromTable::WithFromKeyword(tables) => { write!(f, "FROM {}", display_comma_separated(tables)) } FromTable::WithoutKeyword(tables) => { write!(f, "{}", display_comma_separated(tables)) } } } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Variants for the `SET` family of statements. pub enum Set { /// SQL Standard-style /// SET a = 1; /// `SET var = value` (standard SQL-style assignment). SingleAssignment { /// Optional scope modifier (`SESSION` / `LOCAL`). scope: Option, /// Whether this is a Hive-style `HIVEVAR:` assignment. hivevar: bool, /// Variable name to assign. variable: ObjectName, /// Values assigned to the variable. values: Vec, }, /// Snowflake-style /// SET (a, b, ..) = (1, 2, ..); /// `SET (a, b) = (1, 2)` (tuple assignment syntax). ParenthesizedAssignments { /// Variables being assigned in tuple form. variables: Vec, /// Corresponding values for the variables. values: Vec, }, /// MySQL-style /// SET a = 1, b = 2, ..; /// `SET a = 1, b = 2` (MySQL-style comma-separated assignments). MultipleAssignments { /// List of `SET` assignments (MySQL-style comma-separated). assignments: Vec, }, /// Session authorization for Postgres/Redshift /// /// ```sql /// SET SESSION AUTHORIZATION { user_name | DEFAULT } /// ``` /// /// See /// See SetSessionAuthorization(SetSessionAuthorizationParam), /// MS-SQL session /// /// See SetSessionParam(SetSessionParamKind), /// ```sql /// SET [ SESSION | LOCAL ] ROLE role_name /// ``` /// /// Sets session state. Examples: [ANSI][1], [Postgresql][2], [MySQL][3], and [Oracle][4] /// /// [1]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#set-role-statement /// [2]: https://www.postgresql.org/docs/14/sql-set-role.html /// [3]: https://dev.mysql.com/doc/refman/8.0/en/set-role.html /// [4]: https://docs.oracle.com/cd/B19306_01/server.102/b14200/statements_10004.htm SetRole { /// Non-ANSI optional identifier to inform if the role is defined inside the current session (`SESSION`) or transaction (`LOCAL`). context_modifier: Option, /// Role name. If NONE is specified, then the current role name is removed. role_name: Option, }, /// ```sql /// SET TIME ZONE /// ``` /// /// Note: this is a PostgreSQL-specific statements /// `SET TIME ZONE ` is an alias for `SET timezone TO ` in PostgreSQL /// However, we allow it for all dialects. /// `SET TIME ZONE` statement. `local` indicates the `LOCAL` keyword. /// `SET TIME ZONE ` statement. SetTimeZone { /// Whether the `LOCAL` keyword was specified. local: bool, /// Time zone expression value. value: Expr, }, /// ```sql /// SET NAMES 'charset_name' [COLLATE 'collation_name'] /// ``` SetNames { /// Character set name to set. charset_name: Ident, /// Optional collation name. collation_name: Option, }, /// ```sql /// SET NAMES DEFAULT /// ``` /// /// Note: this is a MySQL-specific statement. SetNamesDefault {}, /// ```sql /// SET TRANSACTION ... /// ``` SetTransaction { /// Transaction modes (e.g., ISOLATION LEVEL, READ ONLY). modes: Vec, /// Optional snapshot value for transaction snapshot control. snapshot: Option, /// `true` when the `SESSION` keyword was used. session: bool, }, } impl Display for Set { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { Self::ParenthesizedAssignments { variables, values } => write!( f, "SET ({}) = ({})", display_comma_separated(variables), display_comma_separated(values) ), Self::MultipleAssignments { assignments } => { write!(f, "SET {}", display_comma_separated(assignments)) } Self::SetRole { context_modifier, role_name, } => { let role_name = role_name.clone().unwrap_or_else(|| Ident::new("NONE")); write!( f, "SET {modifier}ROLE {role_name}", modifier = context_modifier.map(|m| format!("{m}")).unwrap_or_default() ) } Self::SetSessionAuthorization(kind) => write!(f, "SET SESSION AUTHORIZATION {kind}"), Self::SetSessionParam(kind) => write!(f, "SET {kind}"), Self::SetTransaction { modes, snapshot, session, } => { if *session { write!(f, "SET SESSION CHARACTERISTICS AS TRANSACTION")?; } else { write!(f, "SET TRANSACTION")?; } if !modes.is_empty() { write!(f, " {}", display_comma_separated(modes))?; } if let Some(snapshot_id) = snapshot { write!(f, " SNAPSHOT {snapshot_id}")?; } Ok(()) } Self::SetTimeZone { local, value } => { f.write_str("SET ")?; if *local { f.write_str("LOCAL ")?; } write!(f, "TIME ZONE {value}") } Self::SetNames { charset_name, collation_name, } => { write!(f, "SET NAMES {charset_name}")?; if let Some(collation) = collation_name { f.write_str(" COLLATE ")?; f.write_str(collation)?; }; Ok(()) } Self::SetNamesDefault {} => { f.write_str("SET NAMES DEFAULT")?; Ok(()) } Set::SingleAssignment { scope, hivevar, variable, values, } => { write!( f, "SET {}{}{} = {}", scope.map(|s| format!("{s}")).unwrap_or_default(), if *hivevar { "HIVEVAR:" } else { "" }, variable, display_comma_separated(values) ) } } } } /// A representation of a `WHEN` arm with all the identifiers catched and the statements to execute /// for the arm. /// /// Snowflake: /// BigQuery: #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct ExceptionWhen { /// Identifiers that trigger this branch (error conditions). pub idents: Vec, /// Statements to execute when the condition matches. pub statements: Vec, } impl Display for ExceptionWhen { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "WHEN {idents} THEN", idents = display_separated(&self.idents, " OR ") )?; if !self.statements.is_empty() { write!(f, " ")?; format_statement_list(f, &self.statements)?; } Ok(()) } } /// ANALYZE statement /// /// Supported syntax varies by dialect: /// - Hive: `ANALYZE TABLE t [PARTITION (...)] COMPUTE STATISTICS [NOSCAN] [FOR COLUMNS [col1, ...]] [CACHE METADATA]` /// - PostgreSQL: `ANALYZE [VERBOSE] [t [(col1, ...)]]` See /// - General: `ANALYZE [TABLE] t` #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct Analyze { #[cfg_attr(feature = "visitor", visit(with = "visit_relation"))] /// Name of the table to analyze. `None` for bare `ANALYZE`. pub table_name: Option, /// Optional partition expressions to restrict the analysis. pub partitions: Option>, /// `true` when analyzing specific columns (Hive `FOR COLUMNS` syntax). pub for_columns: bool, /// Columns to analyze. pub columns: Vec, /// Whether to cache metadata before analyzing. pub cache_metadata: bool, /// Whether to skip scanning the table. pub noscan: bool, /// Whether to compute statistics during analysis. pub compute_statistics: bool, /// Whether the `TABLE` keyword was present. pub has_table_keyword: bool, } impl fmt::Display for Analyze { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "ANALYZE")?; if let Some(ref table_name) = self.table_name { if self.has_table_keyword { write!(f, " TABLE")?; } write!(f, " {table_name}")?; } if !self.for_columns && !self.columns.is_empty() { write!(f, " ({})", display_comma_separated(&self.columns))?; } if let Some(ref parts) = self.partitions { if !parts.is_empty() { write!(f, " PARTITION ({})", display_comma_separated(parts))?; } } if self.compute_statistics { write!(f, " COMPUTE STATISTICS")?; } if self.noscan { write!(f, " NOSCAN")?; } if self.cache_metadata { write!(f, " CACHE METADATA")?; } if self.for_columns { write!(f, " FOR COLUMNS")?; if !self.columns.is_empty() { write!(f, " {}", display_comma_separated(&self.columns))?; } } Ok(()) } } /// A top-level statement (SELECT, INSERT, CREATE, etc.) #[allow(clippy::large_enum_variant)] #[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_statement") )] pub enum Statement { /// ```sql /// ANALYZE /// ``` /// Analyze (Hive) Analyze(Analyze), /// `SET` statements (session, transaction, timezone, etc.). Set(Set), /// ```sql /// TRUNCATE /// ``` /// Truncate (Hive) Truncate(Truncate), /// ```sql /// MSCK /// ``` /// Msck (Hive) Msck(Msck), /// ```sql /// SELECT /// ``` Query(Box), /// ```sql /// INSERT /// ``` Insert(Insert), /// ```sql /// INSTALL /// ``` Install { /// Only for DuckDB extension_name: Ident, }, /// ```sql /// LOAD /// ``` Load { /// Only for DuckDB extension_name: Ident, }, // TODO: Support ROW FORMAT /// LOAD DATA from a directory or query source. Directory { /// Whether to overwrite existing files. overwrite: bool, /// Whether the directory is local to the server. local: bool, /// Path to the directory or files. path: String, /// Optional file format for the data. file_format: Option, /// Source query providing data to load. source: Box, }, /// A `CASE` statement. Case(CaseStatement), /// An `IF` statement. If(IfStatement), /// A `WHILE` statement. While(WhileStatement), /// A `RAISE` statement. Raise(RaiseStatement), /// ```sql /// CALL /// ``` Call(Function), /// ```sql /// COPY [TO | FROM] ... /// ``` Copy { /// The source of 'COPY TO', or the target of 'COPY FROM' source: CopySource, /// If true, is a 'COPY TO' statement. If false is a 'COPY FROM' to: bool, /// The target of 'COPY TO', or the source of 'COPY FROM' target: CopyTarget, /// WITH options (from PostgreSQL version 9.0) options: Vec, /// WITH options (before PostgreSQL version 9.0) legacy_options: Vec, /// VALUES a vector of values to be copied values: Vec>, }, /// ```sql /// COPY INTO
| /// ``` /// See: /// /// /// /// Copy Into syntax available for Snowflake is different than the one implemented in /// Postgres. Although they share common prefix, it is reasonable to implement them /// in different enums. This can be refactored later once custom dialects /// are allowed to have custom Statements. CopyIntoSnowflake { /// Kind of COPY INTO operation (table or location). kind: CopyIntoSnowflakeKind, /// Target object for the COPY INTO operation. into: ObjectName, /// Optional list of target columns. into_columns: Option>, /// Optional source object name (staged data). from_obj: Option, /// Optional alias for the source object. from_obj_alias: Option, /// Stage-specific parameters (e.g., credentials, path). stage_params: StageParamsObject, /// Optional list of transformations applied when loading. from_transformations: Option>, /// Optional source query instead of a staged object. from_query: Option>, /// Optional list of specific file names to load. files: Option>, /// Optional filename matching pattern. pattern: Option, /// File format options. file_format: KeyValueOptions, /// Additional copy options. copy_options: KeyValueOptions, /// Optional validation mode string. validation_mode: Option, /// Optional partition expression for loading. partition: Option>, }, /// ```sql /// OPEN cursor_name /// ``` /// Opens a cursor. Open(OpenStatement), /// ```sql /// CLOSE /// ``` /// Closes the portal underlying an open cursor. Close { /// Cursor name cursor: CloseCursor, }, /// ```sql /// UPDATE /// ``` Update(Update), /// ```sql /// DELETE /// ``` Delete(Delete), /// ```sql /// CREATE VIEW /// ``` CreateView(CreateView), /// ```sql /// CREATE TABLE /// ``` CreateTable(CreateTable), /// ```sql /// CREATE VIRTUAL TABLE .. USING ()` /// ``` /// Sqlite specific statement CreateVirtualTable { #[cfg_attr(feature = "visitor", visit(with = "visit_relation"))] /// Name of the virtual table module instance. name: ObjectName, /// `true` when `IF NOT EXISTS` was specified. if_not_exists: bool, /// Module name used by the virtual table. module_name: Ident, /// Arguments passed to the module. module_args: Vec, }, /// ```sql /// `CREATE INDEX` /// ``` CreateIndex(CreateIndex), /// ```sql /// CREATE ROLE /// ``` /// See [PostgreSQL](https://www.postgresql.org/docs/current/sql-createrole.html) CreateRole(CreateRole), /// ```sql /// CREATE SECRET /// ``` /// See [DuckDB](https://duckdb.org/docs/sql/statements/create_secret.html) CreateSecret { /// `true` when `OR REPLACE` was specified. or_replace: bool, /// Optional `TEMPORARY` flag. temporary: Option, /// `true` when `IF NOT EXISTS` was present. if_not_exists: bool, /// Optional secret name. name: Option, /// Optional storage specifier identifier. storage_specifier: Option, /// The secret type identifier. secret_type: Ident, /// Additional secret options. options: Vec, }, /// A `CREATE SERVER` statement. CreateServer(CreateServerStatement), /// ```sql /// CREATE POLICY /// ``` /// See [PostgreSQL](https://www.postgresql.org/docs/current/sql-createpolicy.html) CreatePolicy(CreatePolicy), /// ```sql /// CREATE CONNECTOR /// ``` /// See [Hive](https://cwiki.apache.org/confluence/pages/viewpage.action?pageId=27362034#LanguageManualDDL-CreateDataConnectorCreateConnector) CreateConnector(CreateConnector), /// ```sql /// CREATE OPERATOR /// ``` /// See [PostgreSQL](https://www.postgresql.org/docs/current/sql-createoperator.html) CreateOperator(CreateOperator), /// ```sql /// CREATE OPERATOR FAMILY /// ``` /// See [PostgreSQL](https://www.postgresql.org/docs/current/sql-createopfamily.html) CreateOperatorFamily(CreateOperatorFamily), /// ```sql /// CREATE OPERATOR CLASS /// ``` /// See [PostgreSQL](https://www.postgresql.org/docs/current/sql-createopclass.html) CreateOperatorClass(CreateOperatorClass), /// ```sql /// ALTER TABLE /// ``` AlterTable(AlterTable), /// ```sql /// ALTER SCHEMA /// ``` /// See [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language#alter_schema_collate_statement) AlterSchema(AlterSchema), /// ```sql /// ALTER INDEX /// ``` AlterIndex { /// Name of the index to alter. name: ObjectName, /// The operation to perform on the index. operation: AlterIndexOperation, }, /// ```sql /// ALTER VIEW /// ``` AlterView { /// View name being altered. #[cfg_attr(feature = "visitor", visit(with = "visit_relation"))] name: ObjectName, /// Optional new column list for the view. columns: Vec, /// Replacement query for the view definition. query: Box, /// Additional WITH options for the view. with_options: Vec, }, /// ```sql /// ALTER FUNCTION /// ALTER AGGREGATE /// ``` /// See [PostgreSQL](https://www.postgresql.org/docs/current/sql-alterfunction.html) /// and [PostgreSQL](https://www.postgresql.org/docs/current/sql-alteraggregate.html) AlterFunction(AlterFunction), /// ```sql /// ALTER TYPE /// See [PostgreSQL](https://www.postgresql.org/docs/current/sql-altertype.html) /// ``` AlterType(AlterType), /// ```sql /// ALTER COLLATION /// ``` /// See [PostgreSQL](https://www.postgresql.org/docs/current/sql-altercollation.html) AlterCollation(AlterCollation), /// ```sql /// ALTER OPERATOR /// ``` /// See [PostgreSQL](https://www.postgresql.org/docs/current/sql-alteroperator.html) AlterOperator(AlterOperator), /// ```sql /// ALTER OPERATOR FAMILY /// ``` /// See [PostgreSQL](https://www.postgresql.org/docs/current/sql-alteropfamily.html) AlterOperatorFamily(AlterOperatorFamily), /// ```sql /// ALTER OPERATOR CLASS /// ``` /// See [PostgreSQL](https://www.postgresql.org/docs/current/sql-alteropclass.html) AlterOperatorClass(AlterOperatorClass), /// ```sql /// ALTER ROLE /// ``` AlterRole { /// Role name being altered. name: Ident, /// Operation to perform on the role. operation: AlterRoleOperation, }, /// ```sql /// ALTER POLICY ON
[] /// ``` /// (Postgresql-specific) AlterPolicy(AlterPolicy), /// ```sql /// ALTER CONNECTOR connector_name SET DCPROPERTIES(property_name=property_value, ...); /// or /// ALTER CONNECTOR connector_name SET URL new_url; /// or /// ALTER CONNECTOR connector_name SET OWNER [USER|ROLE] user_or_role; /// ``` /// (Hive-specific) AlterConnector { /// Name of the connector to alter. name: Ident, /// Optional connector properties to set. properties: Option>, /// Optional new URL for the connector. url: Option, /// Optional new owner specification. owner: Option, }, /// ```sql /// ALTER SESSION SET sessionParam /// ALTER SESSION UNSET [ , , ... ] /// ``` /// See AlterSession { /// true is to set for the session parameters, false is to unset set: bool, /// The session parameters to set or unset session_params: KeyValueOptions, }, /// ```sql /// ATTACH DATABASE 'path/to/file' AS alias /// ``` /// (SQLite-specific) AttachDatabase { /// The name to bind to the newly attached database schema_name: Ident, /// An expression that indicates the path to the database file database_file_name: Expr, /// true if the syntax is 'ATTACH DATABASE', false if it's just 'ATTACH' database: bool, }, /// (DuckDB-specific) /// ```sql /// ATTACH 'sqlite_file.db' AS sqlite_db (READ_ONLY, TYPE SQLITE); /// ``` /// See AttachDuckDBDatabase { /// `true` when `IF NOT EXISTS` was present. if_not_exists: bool, /// `true` if the syntax used `ATTACH DATABASE` rather than `ATTACH`. database: bool, /// The path identifier to the database file being attached. database_path: Ident, /// Optional alias assigned to the attached database. database_alias: Option, /// Dialect-specific attach options (e.g., `READ_ONLY`). attach_options: Vec, }, /// (DuckDB-specific) /// ```sql /// DETACH db_alias; /// ``` /// See DetachDuckDBDatabase { /// `true` when `IF EXISTS` was present. if_exists: bool, /// `true` if the syntax used `DETACH DATABASE` rather than `DETACH`. database: bool, /// Alias of the database to detach. database_alias: Ident, }, /// ```sql /// DROP [TABLE, VIEW, ...] /// ``` Drop { /// The type of the object to drop: TABLE, VIEW, etc. object_type: ObjectType, /// An optional `IF EXISTS` clause. (Non-standard.) if_exists: bool, /// One or more objects to drop. (ANSI SQL requires exactly one.) names: Vec, /// Whether `CASCADE` was specified. This will be `false` when /// `RESTRICT` or no drop behavior at all was specified. cascade: bool, /// Whether `RESTRICT` was specified. This will be `false` when /// `CASCADE` or no drop behavior at all was specified. restrict: bool, /// Hive allows you specify whether the table's stored data will be /// deleted along with the dropped table purge: bool, /// MySQL-specific "TEMPORARY" keyword temporary: bool, /// MySQL-specific drop index syntax, which requires table specification /// See table: Option, }, /// ```sql /// DROP FUNCTION /// ``` DropFunction(DropFunction), /// ```sql /// DROP DOMAIN /// ``` /// See [PostgreSQL](https://www.postgresql.org/docs/current/sql-dropdomain.html) /// /// DROP DOMAIN [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ] /// DropDomain(DropDomain), /// ```sql /// DROP PROCEDURE /// ``` DropProcedure { /// `true` when `IF EXISTS` was present. if_exists: bool, /// One or more functions/procedures to drop. proc_desc: Vec, /// Optional drop behavior (`CASCADE` or `RESTRICT`). drop_behavior: Option, }, /// ```sql /// DROP SECRET /// ``` DropSecret { /// `true` when `IF EXISTS` was present. if_exists: bool, /// Optional `TEMPORARY` marker. temporary: Option, /// Name of the secret to drop. name: Ident, /// Optional storage specifier identifier. storage_specifier: Option, }, ///```sql /// DROP POLICY /// ``` /// See [PostgreSQL](https://www.postgresql.org/docs/current/sql-droppolicy.html) DropPolicy(DropPolicy), /// ```sql /// DROP CONNECTOR /// ``` /// See [Hive](https://cwiki.apache.org/confluence/pages/viewpage.action?pageId=27362034#LanguageManualDDL-DropConnector) DropConnector { /// `true` when `IF EXISTS` was present. if_exists: bool, /// Name of the connector to drop. name: Ident, }, /// ```sql /// DECLARE /// ``` /// Declare Cursor Variables /// /// Note: this is a PostgreSQL-specific statement, /// but may also compatible with other SQL. Declare { /// Cursor declaration statements collected by `DECLARE`. stmts: Vec, }, /// ```sql /// CREATE EXTENSION [ IF NOT EXISTS ] extension_name /// [ WITH ] [ SCHEMA schema_name ] /// [ VERSION version ] /// [ CASCADE ] /// ``` /// /// Note: this is a PostgreSQL-specific statement, CreateExtension(CreateExtension), /// ```sql /// CREATE COLLATION /// ``` /// Note: this is a PostgreSQL-specific statement. /// CreateCollation(CreateCollation), /// ```sql /// DROP EXTENSION [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ] /// ``` /// Note: this is a PostgreSQL-specific statement. /// DropExtension(DropExtension), /// ```sql /// DROP OPERATOR [ IF EXISTS ] name ( { left_type | NONE } , right_type ) [, ...] [ CASCADE | RESTRICT ] /// ``` /// Note: this is a PostgreSQL-specific statement. /// DropOperator(DropOperator), /// ```sql /// DROP OPERATOR FAMILY [ IF EXISTS ] name USING index_method [ CASCADE | RESTRICT ] /// ``` /// Note: this is a PostgreSQL-specific statement. /// DropOperatorFamily(DropOperatorFamily), /// ```sql /// DROP OPERATOR CLASS [ IF EXISTS ] name USING index_method [ CASCADE | RESTRICT ] /// ``` /// Note: this is a PostgreSQL-specific statement. /// DropOperatorClass(DropOperatorClass), /// ```sql /// FETCH /// ``` /// Retrieve rows from a query using a cursor /// /// Note: this is a PostgreSQL-specific statement, /// but may also compatible with other SQL. Fetch { /// Cursor name name: Ident, /// The fetch direction (e.g., `FORWARD`, `BACKWARD`). direction: FetchDirection, /// The fetch position (e.g., `ALL`, `NEXT`, `ABSOLUTE`). position: FetchPosition, /// Optional target table to fetch rows into. into: Option, }, /// ```sql /// FLUSH [NO_WRITE_TO_BINLOG | LOCAL] flush_option [, flush_option] ... | tables_option /// ``` /// /// Note: this is a Mysql-specific statement, /// but may also compatible with other SQL. Flush { /// The specific flush option or object to flush. object_type: FlushType, /// Optional flush location (dialect-specific). location: Option, /// Optional channel name used for flush operations. channel: Option, /// Whether a read lock was requested. read_lock: bool, /// Whether this is an export flush operation. export: bool, /// Optional list of tables involved in the flush. tables: Vec, }, /// ```sql /// DISCARD [ ALL | PLANS | SEQUENCES | TEMPORARY | TEMP ] /// ``` /// /// Note: this is a PostgreSQL-specific statement, /// but may also compatible with other SQL. Discard { /// The kind of object(s) to discard (ALL, PLANS, etc.). object_type: DiscardObject, }, /// `SHOW FUNCTIONS` /// /// Note: this is a Presto-specific statement. ShowFunctions { /// Optional filter for which functions to display. filter: Option, }, /// ```sql /// SHOW /// ``` /// /// Note: this is a PostgreSQL-specific statement. ShowVariable { /// Variable name as one or more identifiers. variable: Vec, }, /// ```sql /// SHOW [GLOBAL | SESSION] STATUS [LIKE 'pattern' | WHERE expr] /// ``` /// /// Note: this is a MySQL-specific statement. ShowStatus { /// Optional filter for which status entries to display. filter: Option, /// `true` when `GLOBAL` scope was requested. global: bool, /// `true` when `SESSION` scope was requested. session: bool, }, /// ```sql /// SHOW VARIABLES /// ``` /// /// Note: this is a MySQL-specific statement. ShowVariables { /// Optional filter for which variables to display. filter: Option, /// `true` when `GLOBAL` scope was requested. global: bool, /// `true` when `SESSION` scope was requested. session: bool, }, /// ```sql /// SHOW CREATE TABLE /// ``` /// /// Note: this is a MySQL-specific statement. ShowCreate { /// The kind of object being shown (TABLE, VIEW, etc.). obj_type: ShowCreateObject, /// The name of the object to show create statement for. obj_name: ObjectName, }, /// ```sql /// SHOW COLUMNS /// ``` ShowColumns { /// `true` when extended column information was requested. extended: bool, /// `true` when full column details were requested. full: bool, /// Additional options for `SHOW COLUMNS`. show_options: ShowStatementOptions, }, /// ```sql /// SHOW CATALOGS /// ``` ShowCatalogs { /// `true` when terse output format was requested. terse: bool, /// `true` when history information was requested. history: bool, /// Additional options for `SHOW CATALOGS`. show_options: ShowStatementOptions, }, /// ```sql /// SHOW DATABASES /// ``` ShowDatabases { /// `true` when terse output format was requested. terse: bool, /// `true` when history information was requested. history: bool, /// Additional options for `SHOW DATABASES`. show_options: ShowStatementOptions, }, /// ```sql /// SHOW [FULL] PROCESSLIST /// ``` /// /// Note: this is a MySQL-specific statement. ShowProcessList { /// `true` when full process information was requested. full: bool, }, /// ```sql /// SHOW SCHEMAS /// ``` ShowSchemas { /// `true` when terse (compact) output was requested. terse: bool, /// `true` when history information was requested. history: bool, /// Additional options for `SHOW SCHEMAS`. show_options: ShowStatementOptions, }, // ```sql // SHOW {CHARACTER SET | CHARSET} // ``` // [MySQL]: // /// Show the available character sets (alias `CHARSET`). ShowCharset(ShowCharset), /// ```sql /// SHOW OBJECTS LIKE 'line%' IN mydb.public /// ``` /// Snowflake-specific statement /// ShowObjects(ShowObjects), /// ```sql /// SHOW TABLES /// ``` ShowTables { /// `true` when terse output format was requested (compact listing). terse: bool, /// `true` when history rows are requested. history: bool, /// `true` when extended information should be shown. extended: bool, /// `true` when a full listing was requested. full: bool, /// `true` when external tables should be included. external: bool, /// Additional options for `SHOW` statements. show_options: ShowStatementOptions, }, /// ```sql /// SHOW VIEWS /// ``` ShowViews { /// `true` when terse output format was requested. terse: bool, /// `true` when materialized views should be included. materialized: bool, /// Additional options for `SHOW` statements. show_options: ShowStatementOptions, }, /// ```sql /// SHOW COLLATION /// ``` /// /// Note: this is a MySQL-specific statement. ShowCollation { /// Optional filter for which collations to display. filter: Option, }, /// ```sql /// `USE ...` /// ``` Use(Use), /// ```sql /// START [ TRANSACTION | WORK ] | START TRANSACTION } ... /// ``` /// If `begin` is false. /// /// ```sql /// `BEGIN [ TRANSACTION | WORK ] | START TRANSACTION } ...` /// ``` /// If `begin` is true StartTransaction { /// Transaction modes such as `ISOLATION LEVEL` or `READ WRITE`. modes: Vec, /// `true` when this was parsed as `BEGIN` instead of `START`. begin: bool, /// Optional specific keyword used: `TRANSACTION` or `WORK`. transaction: Option, /// Optional transaction modifier (e.g., `AND NO CHAIN`). modifier: Option, /// List of statements belonging to the `BEGIN` block. /// Example: /// ```sql /// BEGIN /// SELECT 1; /// SELECT 2; /// END; /// ``` statements: Vec, /// Exception handling with exception clauses. /// Example: /// ```sql /// EXCEPTION /// WHEN EXCEPTION_1 THEN /// SELECT 2; /// WHEN EXCEPTION_2 OR EXCEPTION_3 THEN /// SELECT 3; /// WHEN OTHER THEN /// SELECT 4; /// ``` /// /// exception: Option>, /// TRUE if the statement has an `END` keyword. has_end_keyword: bool, }, /// ```sql /// COMMENT ON ... /// ``` /// /// Note: this is a PostgreSQL-specific statement. Comment { /// Type of object being commented (table, column, etc.). object_type: CommentObject, /// Name of the object the comment applies to. object_name: ObjectName, /// Optional comment text (None to remove comment). comment: Option, /// An optional `IF EXISTS` clause. (Non-standard.) /// See if_exists: bool, }, /// ```sql /// COMMIT [ TRANSACTION | WORK ] [ AND [ NO ] CHAIN ] /// ``` /// If `end` is false /// /// ```sql /// END [ TRY | CATCH ] /// ``` /// If `end` is true Commit { /// `true` when `AND [ NO ] CHAIN` was present. chain: bool, /// `true` when this `COMMIT` was parsed as an `END` block terminator. end: bool, /// Optional transaction modifier for commit semantics. modifier: Option, }, /// ```sql /// ROLLBACK [ TRANSACTION | WORK ] [ AND [ NO ] CHAIN ] [ TO [ SAVEPOINT ] savepoint_name ] /// ``` Rollback { /// `true` when `AND [ NO ] CHAIN` was present. chain: bool, /// Optional savepoint name to roll back to. savepoint: Option, }, /// ```sql /// CREATE SCHEMA /// ``` CreateSchema { /// ` | AUTHORIZATION | AUTHORIZATION ` schema_name: SchemaName, /// `true` when `IF NOT EXISTS` was present. if_not_exists: bool, /// Schema properties. /// /// ```sql /// CREATE SCHEMA myschema WITH (key1='value1'); /// ``` /// /// [Trino](https://trino.io/docs/current/sql/create-schema.html) with: Option>, /// Schema options. /// /// ```sql /// CREATE SCHEMA myschema OPTIONS(key1='value1'); /// ``` /// /// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language#create_schema_statement) options: Option>, /// Default collation specification for the schema. /// /// ```sql /// CREATE SCHEMA myschema DEFAULT COLLATE 'und:ci'; /// ``` /// /// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language#create_schema_statement) default_collate_spec: Option, /// Clones a schema /// /// ```sql /// CREATE SCHEMA myschema CLONE otherschema /// ``` /// /// [Snowflake](https://docs.snowflake.com/en/sql-reference/sql/create-clone#databases-schemas) clone: Option, }, /// ```sql /// CREATE DATABASE /// ``` /// See: /// CreateDatabase { /// Database name. db_name: ObjectName, /// `IF NOT EXISTS` flag. if_not_exists: bool, /// Optional location URI. location: Option, /// Optional managed location. managed_location: Option, /// `OR REPLACE` flag. or_replace: bool, /// `TRANSIENT` flag. transient: bool, /// Optional clone source. clone: Option, /// Optional data retention time in days. data_retention_time_in_days: Option, /// Optional maximum data extension time in days. max_data_extension_time_in_days: Option, /// Optional external volume identifier. external_volume: Option, /// Optional catalog name. catalog: Option, /// Whether to replace invalid characters. replace_invalid_characters: Option, /// Default DDL collation string. default_ddl_collation: Option, /// Storage serialization policy. storage_serialization_policy: Option, /// Optional comment. comment: Option, /// Optional default character set (MySQL). default_charset: Option, /// Optional default collation (MySQL). default_collation: Option, /// Optional catalog sync identifier. catalog_sync: Option, /// Catalog sync namespace mode. catalog_sync_namespace_mode: Option, /// Optional flatten delimiter for namespace sync. catalog_sync_namespace_flatten_delimiter: Option, /// Optional tags for the database. with_tags: Option>, /// Optional contact entries for the database. with_contacts: Option>, }, /// ```sql /// CREATE FUNCTION /// ``` /// /// Supported variants: /// 1. [Hive](https://cwiki.apache.org/confluence/display/hive/languagemanual+ddl#LanguageManualDDL-Create/Drop/ReloadFunction) /// 2. [PostgreSQL](https://www.postgresql.org/docs/15/sql-createfunction.html) /// 3. [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language#create_function_statement) /// 4. [MsSql](https://learn.microsoft.com/en-us/sql/t-sql/statements/create-function-transact-sql) CreateFunction(CreateFunction), /// CREATE TRIGGER statement. See struct [CreateTrigger] for details. CreateTrigger(CreateTrigger), /// DROP TRIGGER statement. See struct [DropTrigger] for details. DropTrigger(DropTrigger), /// ```sql /// CREATE PROCEDURE /// ``` CreateProcedure { /// `OR ALTER` flag. or_alter: bool, /// Procedure name. name: ObjectName, /// Optional procedure parameters. params: Option>, /// Optional language identifier. language: Option, /// Procedure body statements. body: ConditionalStatements, }, /// ```sql /// CREATE MACRO /// ``` /// /// Supported variants: /// 1. [DuckDB](https://duckdb.org/docs/sql/statements/create_macro) CreateMacro { /// `OR REPLACE` flag. or_replace: bool, /// Whether macro is temporary. temporary: bool, /// Macro name. name: ObjectName, /// Optional macro arguments. args: Option>, /// Macro definition body. definition: MacroDefinition, }, /// ```sql /// CREATE STAGE /// ``` /// See CreateStage { /// `OR REPLACE` flag for stage. or_replace: bool, /// Whether stage is temporary. temporary: bool, /// `IF NOT EXISTS` flag. if_not_exists: bool, /// Stage name. name: ObjectName, /// Stage parameters. stage_params: StageParamsObject, /// Directory table parameters. directory_table_params: KeyValueOptions, /// File format options. file_format: KeyValueOptions, /// Copy options for stage. copy_options: KeyValueOptions, /// Optional comment. comment: Option, }, /// ```sql /// ASSERT [AS ] /// ``` Assert { /// Assertion condition expression. condition: Expr, /// Optional message expression. message: Option, }, /// ```sql /// GRANT privileges ON objects TO grantees /// ``` Grant(Grant), /// ```sql /// DENY privileges ON object TO grantees /// ``` Deny(DenyStatement), /// ```sql /// REVOKE privileges ON objects FROM grantees /// ``` Revoke(Revoke), /// ```sql /// DEALLOCATE [ PREPARE ] { name | ALL } /// ``` /// /// Note: this is a PostgreSQL-specific statement. Deallocate { /// Name to deallocate (or `ALL`). name: Ident, /// Whether `PREPARE` keyword was present. prepare: bool, }, /// ```sql /// An `EXECUTE` statement /// ``` /// /// Postgres: /// MSSQL: /// BigQuery: /// Snowflake: Execute { /// Optional function/procedure name. name: Option, /// Parameter expressions passed to execute. parameters: Vec, /// Whether parentheses were present around `parameters`. has_parentheses: bool, /// Is this an `EXECUTE IMMEDIATE`. immediate: bool, /// Identifiers to capture results into. into: Vec, /// `USING` expressions with optional aliases. using: Vec, /// Whether the last parameter is the return value of the procedure /// MSSQL: output: bool, /// Whether to invoke the procedure with the default parameter values /// MSSQL: default: bool, }, /// ```sql /// PREPARE name [ ( data_type [, ...] ) ] AS statement /// ``` /// /// Note: this is a PostgreSQL-specific statement. Prepare { /// Name of the prepared statement. name: Ident, /// Optional data types for parameters. data_types: Vec, /// Statement being prepared. statement: Box, }, /// ```sql /// KILL [CONNECTION | QUERY | MUTATION] /// ``` /// /// See /// See Kill { /// Optional kill modifier (CONNECTION, QUERY, MUTATION). modifier: Option, // processlist_id /// The id of the process to kill. id: u64, }, /// ```sql /// [EXPLAIN | DESC | DESCRIBE] TABLE /// ``` /// Note: this is a MySQL-specific statement. See ExplainTable { /// `EXPLAIN | DESC | DESCRIBE` describe_alias: DescribeAlias, /// Hive style `FORMATTED | EXTENDED` hive_format: Option, /// Snowflake and ClickHouse support `DESC|DESCRIBE TABLE ` syntax /// /// [Snowflake](https://docs.snowflake.com/en/sql-reference/sql/desc-table.html) /// [ClickHouse](https://clickhouse.com/docs/en/sql-reference/statements/describe-table) has_table_keyword: bool, /// Table name #[cfg_attr(feature = "visitor", visit(with = "visit_relation"))] table_name: ObjectName, }, /// ```sql /// [EXPLAIN | DESC | DESCRIBE] /// ``` Explain { /// `EXPLAIN | DESC | DESCRIBE` describe_alias: DescribeAlias, /// Carry out the command and show actual run times and other statistics. analyze: bool, /// Display additional information regarding the plan. verbose: bool, /// `EXPLAIN QUERY PLAN` /// Display the query plan without running the query. /// /// [SQLite](https://sqlite.org/lang_explain.html) query_plan: bool, /// `EXPLAIN ESTIMATE` /// [Clickhouse](https://clickhouse.com/docs/en/sql-reference/statements/explain#explain-estimate) estimate: bool, /// A SQL query that specifies what to explain statement: Box, /// Optional output format of explain format: Option, /// Postgres style utility options, `(analyze, verbose true)` options: Option>, }, /// ```sql /// SAVEPOINT /// ``` /// Define a new savepoint within the current transaction Savepoint { /// Name of the savepoint being defined. name: Ident, }, /// ```sql /// RELEASE [ SAVEPOINT ] savepoint_name /// ``` ReleaseSavepoint { /// Name of the savepoint to release. name: Ident, }, /// A `MERGE` statement. /// /// ```sql /// MERGE INTO USING ON { matchedClause | notMatchedClause } [ ... ] /// ``` /// [Snowflake](https://docs.snowflake.com/en/sql-reference/sql/merge) /// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/dml-syntax#merge_statement) /// [MSSQL](https://learn.microsoft.com/en-us/sql/t-sql/statements/merge-transact-sql?view=sql-server-ver16) Merge(Merge), /// ```sql /// CACHE [ FLAG ] TABLE [ OPTIONS('K1' = 'V1', 'K2' = V2) ] [ AS ] [ ] /// ``` /// /// See [Spark SQL docs] for more details. /// /// [Spark SQL docs]: https://docs.databricks.com/spark/latest/spark-sql/language-manual/sql-ref-syntax-aux-cache-cache-table.html Cache { /// Table flag table_flag: Option, /// Table name #[cfg_attr(feature = "visitor", visit(with = "visit_relation"))] table_name: ObjectName, /// `true` if `AS` keyword was present before the query. has_as: bool, /// Table confs options: Vec, /// Cache table as a Query query: Option>, }, /// ```sql /// UNCACHE TABLE [ IF EXISTS ] /// ``` UNCache { /// Table name #[cfg_attr(feature = "visitor", visit(with = "visit_relation"))] table_name: ObjectName, /// `true` when `IF EXISTS` was present. if_exists: bool, }, /// ```sql /// CREATE [ { TEMPORARY | TEMP } ] SEQUENCE [ IF NOT EXISTS ] /// ``` /// Define a new sequence: CreateSequence { /// Whether the sequence is temporary. temporary: bool, /// `IF NOT EXISTS` flag. if_not_exists: bool, /// Sequence name. name: ObjectName, /// Optional data type for the sequence. data_type: Option, /// Sequence options (INCREMENT, MINVALUE, etc.). sequence_options: Vec, /// Optional `OWNED BY` target. owned_by: Option, }, /// A `CREATE DOMAIN` statement. CreateDomain(CreateDomain), /// ```sql /// CREATE TYPE /// ``` CreateType { /// Type name to create. name: ObjectName, /// Optional type representation details. representation: Option, }, /// ```sql /// PRAGMA . = /// ``` Pragma { /// Pragma name (possibly qualified). name: ObjectName, /// Optional pragma value. value: Option, /// Whether the pragma used `=`. is_eq: bool, }, /// ```sql /// LOCK [ TABLE ] [ ONLY ] name [ * ] [, ...] [ IN lockmode MODE ] [ NOWAIT ] /// ``` /// /// See Lock(Lock), /// ```sql /// LOCK TABLES [READ [LOCAL] | [LOW_PRIORITY] WRITE] /// ``` /// Note: this is a MySQL-specific statement. See LockTables { /// List of tables to lock with modes. tables: Vec, }, /// ```sql /// UNLOCK TABLES /// ``` /// Note: this is a MySQL-specific statement. See UnlockTables, /// Unloads the result of a query to file /// /// [Athena](https://docs.aws.amazon.com/athena/latest/ug/unload.html): /// ```sql /// UNLOAD(statement) TO [ WITH options ] /// ``` /// /// [Redshift](https://docs.aws.amazon.com/redshift/latest/dg/r_UNLOAD.html): /// ```sql /// UNLOAD('statement') TO [ OPTIONS ] /// ``` Unload { /// Optional query AST to unload. query: Option>, /// Optional original query text. query_text: Option, /// Destination identifier. to: Ident, /// Optional IAM role/auth information. auth: Option, /// Additional `WITH` options. with: Vec, /// Legacy copy-style options. options: Vec, }, /// ClickHouse: /// ```sql /// OPTIMIZE TABLE [db.]name [ON CLUSTER cluster] [PARTITION partition | PARTITION ID 'partition_id'] [FINAL] [DEDUPLICATE [BY expression]] /// ``` /// See ClickHouse /// /// Databricks: /// ```sql /// OPTIMIZE table_name [WHERE predicate] [ZORDER BY (col_name1 [, ...])] /// ``` /// See Databricks OptimizeTable { /// Table name to optimize. name: ObjectName, /// Whether the `TABLE` keyword was present (ClickHouse uses `OPTIMIZE TABLE`, Databricks uses `OPTIMIZE`). has_table_keyword: bool, /// Optional cluster identifier. /// [ClickHouse](https://clickhouse.com/docs/en/sql-reference/statements/optimize) on_cluster: Option, /// Optional partition spec. /// [ClickHouse](https://clickhouse.com/docs/en/sql-reference/statements/optimize) partition: Option, /// Whether `FINAL` was specified. /// [ClickHouse](https://clickhouse.com/docs/en/sql-reference/statements/optimize) include_final: bool, /// Optional deduplication settings. /// [ClickHouse](https://clickhouse.com/docs/en/sql-reference/statements/optimize) deduplicate: Option, /// Optional WHERE predicate. /// [Databricks](https://docs.databricks.com/en/sql/language-manual/delta-optimize.html) predicate: Option, /// Optional ZORDER BY columns. /// [Databricks](https://docs.databricks.com/en/sql/language-manual/delta-optimize.html) zorder: Option>, }, /// ```sql /// LISTEN /// ``` /// listen for a notification channel /// /// See Postgres LISTEN { /// Notification channel identifier. channel: Ident, }, /// ```sql /// UNLISTEN /// ``` /// stop listening for a notification /// /// See Postgres UNLISTEN { /// Notification channel identifier. channel: Ident, }, /// ```sql /// NOTIFY channel [ , payload ] /// ``` /// send a notification event together with an optional "payload" string to channel /// /// See Postgres NOTIFY { /// Notification channel identifier. channel: Ident, /// Optional payload string. payload: Option, }, /// ```sql /// LOAD DATA [LOCAL] INPATH 'filepath' [OVERWRITE] INTO TABLE tablename /// [PARTITION (partcol1=val1, partcol2=val2 ...)] /// [INPUTFORMAT 'inputformat' SERDE 'serde'] /// ``` /// Loading files into tables /// /// See Hive LoadData { /// Whether `LOCAL` is present. local: bool, /// Input path for files to load. inpath: String, /// Whether `OVERWRITE` was specified. overwrite: bool, /// Target table name to load into. table_name: ObjectName, /// Optional partition specification. partitioned: Option>, /// Optional table format information. table_format: Option, }, /// ```sql /// Rename TABLE tbl_name TO new_tbl_name[, tbl_name2 TO new_tbl_name2] ... /// ``` /// Renames one or more tables /// /// See Mysql RenameTable(Vec), /// Snowflake `LIST` /// See: List(FileStagingCommand), /// Snowflake `REMOVE` /// See: Remove(FileStagingCommand), /// RaiseError (MSSQL) /// RAISERROR ( { msg_id | msg_str | @local_variable } /// { , severity , state } /// [ , argument [ , ...n ] ] ) /// [ WITH option [ , ...n ] ] /// See RaisError { /// Error message expression or identifier. message: Box, /// Severity expression. severity: Box, /// State expression. state: Box, /// Substitution arguments for the message. arguments: Vec, /// Additional `WITH` options for RAISERROR. options: Vec, }, /// A MSSQL `THROW` statement. Throw(ThrowStatement), /// ```sql /// PRINT msg_str | @local_variable | string_expr /// ``` /// /// See: Print(PrintStatement), /// MSSQL `WAITFOR` statement. /// /// See: WaitFor(WaitForStatement), /// ```sql /// RETURN [ expression ] /// ``` /// /// See [ReturnStatement] Return(ReturnStatement), /// Export data statement /// /// Example: /// ```sql /// EXPORT DATA OPTIONS(uri='gs://bucket/folder/*', format='PARQUET', overwrite=true) AS /// SELECT field1, field2 FROM mydataset.table1 ORDER BY field1 LIMIT 10 /// ``` /// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/export-statements) ExportData(ExportData), /// ```sql /// CREATE [OR REPLACE] USER [IF NOT EXISTS] /// ``` /// [Snowflake](https://docs.snowflake.com/en/sql-reference/sql/create-user) CreateUser(CreateUser), /// ```sql /// ALTER USER \[ IF EXISTS \] \[ \] /// ``` /// [Snowflake](https://docs.snowflake.com/en/sql-reference/sql/alter-user) AlterUser(AlterUser), /// Re-sorts rows and reclaims space in either a specified table or all tables in the current database /// /// ```sql /// VACUUM tbl /// ``` /// [Redshift](https://docs.aws.amazon.com/redshift/latest/dg/r_VACUUM_command.html) Vacuum(VacuumStatement), /// Restore the value of a run-time parameter to the default value. /// /// ```sql /// RESET configuration_parameter; /// RESET ALL; /// ``` /// [PostgreSQL](https://www.postgresql.org/docs/current/sql-reset.html) Reset(ResetStatement), } impl From for Statement { fn from(analyze: Analyze) -> Self { Statement::Analyze(analyze) } } impl From for Statement { fn from(truncate: ddl::Truncate) -> Self { Statement::Truncate(truncate) } } impl From for Statement { fn from(lock: Lock) -> Self { Statement::Lock(lock) } } impl From for Statement { fn from(msck: ddl::Msck) -> Self { Statement::Msck(msck) } } /// ```sql /// {COPY | REVOKE} CURRENT GRANTS /// ``` /// /// - [Snowflake](https://docs.snowflake.com/en/sql-reference/sql/grant-ownership#optional-parameters) #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum CurrentGrantsKind { /// `COPY CURRENT GRANTS` (copy current grants to target). CopyCurrentGrants, /// `REVOKE CURRENT GRANTS` (revoke current grants from target). RevokeCurrentGrants, } impl fmt::Display for CurrentGrantsKind { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { CurrentGrantsKind::CopyCurrentGrants => write!(f, "COPY CURRENT GRANTS"), CurrentGrantsKind::RevokeCurrentGrants => write!(f, "REVOKE CURRENT GRANTS"), } } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// `RAISERROR` options /// See pub enum RaisErrorOption { /// Log the error. Log, /// Do not wait for completion. NoWait, /// Set the error state. SetError, } impl fmt::Display for RaisErrorOption { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { RaisErrorOption::Log => write!(f, "LOG"), RaisErrorOption::NoWait => write!(f, "NOWAIT"), RaisErrorOption::SetError => write!(f, "SETERROR"), } } } impl fmt::Display for Statement { /// Formats a SQL statement with support for pretty printing. /// /// When using the alternate flag (`{:#}`), the statement will be formatted with proper /// indentation and line breaks. For example: /// /// ``` /// # use sqlparser::dialect::GenericDialect; /// # use sqlparser::parser::Parser; /// let sql = "SELECT a, b FROM table_1"; /// let ast = Parser::parse_sql(&GenericDialect, sql).unwrap(); /// /// // Regular formatting /// assert_eq!(format!("{}", ast[0]), "SELECT a, b FROM table_1"); /// /// // Pretty printing /// assert_eq!(format!("{:#}", ast[0]), /// r#"SELECT /// a, /// b /// FROM /// table_1"#); /// ``` // Clippy thinks this function is too complicated, but it is painful to // split up without extracting structs for each `Statement` variant. #[allow(clippy::cognitive_complexity)] fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { Statement::Flush { object_type, location, channel, read_lock, export, tables, } => { write!(f, "FLUSH")?; if let Some(location) = location { f.write_str(" ")?; location.fmt(f)?; } write!(f, " {object_type}")?; if let Some(channel) = channel { write!(f, " FOR CHANNEL {channel}")?; } write!( f, "{tables}{read}{export}", tables = if !tables.is_empty() { format!(" {}", display_comma_separated(tables)) } else { String::new() }, export = if *export { " FOR EXPORT" } else { "" }, read = if *read_lock { " WITH READ LOCK" } else { "" } ) } Statement::Kill { modifier, id } => { write!(f, "KILL ")?; if let Some(m) = modifier { write!(f, "{m} ")?; } write!(f, "{id}") } Statement::ExplainTable { describe_alias, hive_format, has_table_keyword, table_name, } => { write!(f, "{describe_alias} ")?; if let Some(format) = hive_format { write!(f, "{format} ")?; } if *has_table_keyword { write!(f, "TABLE ")?; } write!(f, "{table_name}") } Statement::Explain { describe_alias, verbose, analyze, query_plan, estimate, statement, format, options, } => { write!(f, "{describe_alias} ")?; if *query_plan { write!(f, "QUERY PLAN ")?; } if *analyze { write!(f, "ANALYZE ")?; } if *estimate { write!(f, "ESTIMATE ")?; } if *verbose { write!(f, "VERBOSE ")?; } if let Some(format) = format { write!(f, "{format} ")?; } if let Some(options) = options { write!(f, "({}) ", display_comma_separated(options))?; } write!(f, "{statement}") } Statement::Query(s) => s.fmt(f), Statement::Declare { stmts } => { write!(f, "DECLARE ")?; write!(f, "{}", display_separated(stmts, "; ")) } Statement::Fetch { name, direction, position, into, } => { write!(f, "FETCH {direction} {position} {name}")?; if let Some(into) = into { write!(f, " INTO {into}")?; } Ok(()) } Statement::Directory { overwrite, local, path, file_format, source, } => { write!( f, "INSERT{overwrite}{local} DIRECTORY '{path}'", overwrite = if *overwrite { " OVERWRITE" } else { "" }, local = if *local { " LOCAL" } else { "" }, path = path )?; if let Some(ref ff) = file_format { write!(f, " STORED AS {ff}")? } write!(f, " {source}") } Statement::Msck(msck) => msck.fmt(f), Statement::Truncate(truncate) => truncate.fmt(f), Statement::Case(stmt) => { write!(f, "{stmt}") } Statement::If(stmt) => { write!(f, "{stmt}") } Statement::While(stmt) => { write!(f, "{stmt}") } Statement::Raise(stmt) => { write!(f, "{stmt}") } Statement::AttachDatabase { schema_name, database_file_name, database, } => { let keyword = if *database { "DATABASE " } else { "" }; write!(f, "ATTACH {keyword}{database_file_name} AS {schema_name}") } Statement::AttachDuckDBDatabase { if_not_exists, database, database_path, database_alias, attach_options, } => { write!( f, "ATTACH{database}{if_not_exists} {database_path}", database = if *database { " DATABASE" } else { "" }, if_not_exists = if *if_not_exists { " IF NOT EXISTS" } else { "" }, )?; if let Some(alias) = database_alias { write!(f, " AS {alias}")?; } if !attach_options.is_empty() { write!(f, " ({})", display_comma_separated(attach_options))?; } Ok(()) } Statement::DetachDuckDBDatabase { if_exists, database, database_alias, } => { write!( f, "DETACH{database}{if_exists} {database_alias}", database = if *database { " DATABASE" } else { "" }, if_exists = if *if_exists { " IF EXISTS" } else { "" }, )?; Ok(()) } Statement::Analyze(analyze) => analyze.fmt(f), Statement::Insert(insert) => insert.fmt(f), Statement::Install { extension_name: name, } => write!(f, "INSTALL {name}"), Statement::Load { extension_name: name, } => write!(f, "LOAD {name}"), Statement::Call(function) => write!(f, "CALL {function}"), Statement::Copy { source, to, target, options, legacy_options, values, } => { write!(f, "COPY")?; match source { CopySource::Query(query) => write!(f, " ({query})")?, CopySource::Table { table_name, columns, } => { write!(f, " {table_name}")?; if !columns.is_empty() { write!(f, " ({})", display_comma_separated(columns))?; } } } write!(f, " {} {}", if *to { "TO" } else { "FROM" }, target)?; if !options.is_empty() { write!(f, " ({})", display_comma_separated(options))?; } if !legacy_options.is_empty() { write!(f, " {}", display_separated(legacy_options, " "))?; } if !values.is_empty() { writeln!(f, ";")?; let mut delim = ""; for v in values { write!(f, "{delim}")?; delim = "\t"; if let Some(v) = v { write!(f, "{v}")?; } else { write!(f, "\\N")?; } } write!(f, "\n\\.")?; } Ok(()) } Statement::Update(update) => update.fmt(f), Statement::Delete(delete) => delete.fmt(f), Statement::Open(open) => open.fmt(f), Statement::Close { cursor } => { write!(f, "CLOSE {cursor}")?; Ok(()) } Statement::CreateDatabase { db_name, if_not_exists, location, managed_location, or_replace, transient, clone, data_retention_time_in_days, max_data_extension_time_in_days, external_volume, catalog, replace_invalid_characters, default_ddl_collation, storage_serialization_policy, comment, default_charset, default_collation, catalog_sync, catalog_sync_namespace_mode, catalog_sync_namespace_flatten_delimiter, with_tags, with_contacts, } => { write!( f, "CREATE {or_replace}{transient}DATABASE {if_not_exists}{name}", or_replace = if *or_replace { "OR REPLACE " } else { "" }, transient = if *transient { "TRANSIENT " } else { "" }, if_not_exists = if *if_not_exists { "IF NOT EXISTS " } else { "" }, name = db_name, )?; if let Some(l) = location { write!(f, " LOCATION '{l}'")?; } if let Some(ml) = managed_location { write!(f, " MANAGEDLOCATION '{ml}'")?; } if let Some(clone) = clone { write!(f, " CLONE {clone}")?; } if let Some(value) = data_retention_time_in_days { write!(f, " DATA_RETENTION_TIME_IN_DAYS = {value}")?; } if let Some(value) = max_data_extension_time_in_days { write!(f, " MAX_DATA_EXTENSION_TIME_IN_DAYS = {value}")?; } if let Some(vol) = external_volume { write!(f, " EXTERNAL_VOLUME = '{vol}'")?; } if let Some(cat) = catalog { write!(f, " CATALOG = '{cat}'")?; } if let Some(true) = replace_invalid_characters { write!(f, " REPLACE_INVALID_CHARACTERS = TRUE")?; } else if let Some(false) = replace_invalid_characters { write!(f, " REPLACE_INVALID_CHARACTERS = FALSE")?; } if let Some(collation) = default_ddl_collation { write!(f, " DEFAULT_DDL_COLLATION = '{collation}'")?; } if let Some(policy) = storage_serialization_policy { write!(f, " STORAGE_SERIALIZATION_POLICY = {policy}")?; } if let Some(comment) = comment { write!(f, " COMMENT = '{comment}'")?; } if let Some(charset) = default_charset { write!(f, " DEFAULT CHARACTER SET {charset}")?; } if let Some(collation) = default_collation { write!(f, " DEFAULT COLLATE {collation}")?; } if let Some(sync) = catalog_sync { write!(f, " CATALOG_SYNC = '{sync}'")?; } if let Some(mode) = catalog_sync_namespace_mode { write!(f, " CATALOG_SYNC_NAMESPACE_MODE = {mode}")?; } if let Some(delim) = catalog_sync_namespace_flatten_delimiter { write!(f, " CATALOG_SYNC_NAMESPACE_FLATTEN_DELIMITER = '{delim}'")?; } if let Some(tags) = with_tags { write!(f, " WITH TAG ({})", display_comma_separated(tags))?; } if let Some(contacts) = with_contacts { write!(f, " WITH CONTACT ({})", display_comma_separated(contacts))?; } Ok(()) } Statement::CreateFunction(create_function) => create_function.fmt(f), Statement::CreateDomain(create_domain) => create_domain.fmt(f), Statement::CreateTrigger(create_trigger) => create_trigger.fmt(f), Statement::DropTrigger(drop_trigger) => drop_trigger.fmt(f), Statement::CreateProcedure { name, or_alter, params, language, body, } => { write!( f, "CREATE {or_alter}PROCEDURE {name}", or_alter = if *or_alter { "OR ALTER " } else { "" }, name = name )?; if let Some(p) = params { if !p.is_empty() { write!(f, " ({})", display_comma_separated(p))?; } } if let Some(language) = language { write!(f, " LANGUAGE {language}")?; } write!(f, " AS {body}") } Statement::CreateMacro { or_replace, temporary, name, args, definition, } => { write!( f, "CREATE {or_replace}{temp}MACRO {name}", temp = if *temporary { "TEMPORARY " } else { "" }, or_replace = if *or_replace { "OR REPLACE " } else { "" }, )?; if let Some(args) = args { write!(f, "({})", display_comma_separated(args))?; } match definition { MacroDefinition::Expr(expr) => write!(f, " AS {expr}")?, MacroDefinition::Table(query) => write!(f, " AS TABLE {query}")?, } Ok(()) } Statement::CreateView(create_view) => create_view.fmt(f), Statement::CreateTable(create_table) => create_table.fmt(f), Statement::LoadData { local, inpath, overwrite, table_name, partitioned, table_format, } => { write!( f, "LOAD DATA {local}INPATH '{inpath}' {overwrite}INTO TABLE {table_name}", local = if *local { "LOCAL " } else { "" }, inpath = inpath, overwrite = if *overwrite { "OVERWRITE " } else { "" }, table_name = table_name, )?; if let Some(ref parts) = &partitioned { if !parts.is_empty() { write!(f, " PARTITION ({})", display_comma_separated(parts))?; } } if let Some(HiveLoadDataFormat { serde, input_format, }) = &table_format { write!(f, " INPUTFORMAT {input_format} SERDE {serde}")?; } Ok(()) } Statement::CreateVirtualTable { name, if_not_exists, module_name, module_args, } => { write!( f, "CREATE VIRTUAL TABLE {if_not_exists}{name} USING {module_name}", if_not_exists = if *if_not_exists { "IF NOT EXISTS " } else { "" }, name = name, module_name = module_name )?; if !module_args.is_empty() { write!(f, " ({})", display_comma_separated(module_args))?; } Ok(()) } Statement::CreateIndex(create_index) => create_index.fmt(f), Statement::CreateExtension(create_extension) => write!(f, "{create_extension}"), Statement::CreateCollation(create_collation) => write!(f, "{create_collation}"), Statement::DropExtension(drop_extension) => write!(f, "{drop_extension}"), Statement::DropOperator(drop_operator) => write!(f, "{drop_operator}"), Statement::DropOperatorFamily(drop_operator_family) => { write!(f, "{drop_operator_family}") } Statement::DropOperatorClass(drop_operator_class) => { write!(f, "{drop_operator_class}") } Statement::CreateRole(create_role) => write!(f, "{create_role}"), Statement::CreateSecret { or_replace, temporary, if_not_exists, name, storage_specifier, secret_type, options, } => { write!( f, "CREATE {or_replace}", or_replace = if *or_replace { "OR REPLACE " } else { "" }, )?; if let Some(t) = temporary { write!(f, "{}", if *t { "TEMPORARY " } else { "PERSISTENT " })?; } write!( f, "SECRET {if_not_exists}", if_not_exists = if *if_not_exists { "IF NOT EXISTS " } else { "" }, )?; if let Some(n) = name { write!(f, "{n} ")?; }; if let Some(s) = storage_specifier { write!(f, "IN {s} ")?; } write!(f, "( TYPE {secret_type}",)?; if !options.is_empty() { write!(f, ", {o}", o = display_comma_separated(options))?; } write!(f, " )")?; Ok(()) } Statement::CreateServer(stmt) => { write!(f, "{stmt}") } Statement::CreatePolicy(policy) => write!(f, "{policy}"), Statement::CreateConnector(create_connector) => create_connector.fmt(f), Statement::CreateOperator(create_operator) => create_operator.fmt(f), Statement::CreateOperatorFamily(create_operator_family) => { create_operator_family.fmt(f) } Statement::CreateOperatorClass(create_operator_class) => create_operator_class.fmt(f), Statement::AlterTable(alter_table) => write!(f, "{alter_table}"), Statement::AlterIndex { name, operation } => { write!(f, "ALTER INDEX {name} {operation}") } Statement::AlterView { name, columns, query, with_options, } => { write!(f, "ALTER VIEW {name}")?; if !with_options.is_empty() { write!(f, " WITH ({})", display_comma_separated(with_options))?; } if !columns.is_empty() { write!(f, " ({})", display_comma_separated(columns))?; } write!(f, " AS {query}") } Statement::AlterFunction(alter_function) => write!(f, "{alter_function}"), Statement::AlterType(AlterType { name, operation }) => { write!(f, "ALTER TYPE {name} {operation}") } Statement::AlterCollation(alter_collation) => write!(f, "{alter_collation}"), Statement::AlterOperator(alter_operator) => write!(f, "{alter_operator}"), Statement::AlterOperatorFamily(alter_operator_family) => { write!(f, "{alter_operator_family}") } Statement::AlterOperatorClass(alter_operator_class) => { write!(f, "{alter_operator_class}") } Statement::AlterRole { name, operation } => { write!(f, "ALTER ROLE {name} {operation}") } Statement::AlterPolicy(alter_policy) => write!(f, "{alter_policy}"), Statement::AlterConnector { name, properties, url, owner, } => { write!(f, "ALTER CONNECTOR {name}")?; if let Some(properties) = properties { write!( f, " SET DCPROPERTIES({})", display_comma_separated(properties) )?; } if let Some(url) = url { write!(f, " SET URL '{url}'")?; } if let Some(owner) = owner { write!(f, " SET OWNER {owner}")?; } Ok(()) } Statement::AlterSession { set, session_params, } => { write!( f, "ALTER SESSION {set}", set = if *set { "SET" } else { "UNSET" } )?; if !session_params.options.is_empty() { if *set { write!(f, " {session_params}")?; } else { let options = session_params .options .iter() .map(|p| p.option_name.clone()) .collect::>(); write!(f, " {}", display_separated(&options, ", "))?; } } Ok(()) } Statement::Drop { object_type, if_exists, names, cascade, restrict, purge, temporary, table, } => { write!( f, "DROP {}{}{} {}{}{}{}", if *temporary { "TEMPORARY " } else { "" }, object_type, if *if_exists { " IF EXISTS" } else { "" }, display_comma_separated(names), if *cascade { " CASCADE" } else { "" }, if *restrict { " RESTRICT" } else { "" }, if *purge { " PURGE" } else { "" }, )?; if let Some(table_name) = table.as_ref() { write!(f, " ON {table_name}")?; }; Ok(()) } Statement::DropFunction(drop_function) => write!(f, "{drop_function}"), Statement::DropDomain(DropDomain { if_exists, name, drop_behavior, }) => { write!( f, "DROP DOMAIN{} {name}", if *if_exists { " IF EXISTS" } else { "" }, )?; if let Some(op) = drop_behavior { write!(f, " {op}")?; } Ok(()) } Statement::DropProcedure { if_exists, proc_desc, drop_behavior, } => { write!( f, "DROP PROCEDURE{} {}", if *if_exists { " IF EXISTS" } else { "" }, display_comma_separated(proc_desc), )?; if let Some(op) = drop_behavior { write!(f, " {op}")?; } Ok(()) } Statement::DropSecret { if_exists, temporary, name, storage_specifier, } => { write!(f, "DROP ")?; if let Some(t) = temporary { write!(f, "{}", if *t { "TEMPORARY " } else { "PERSISTENT " })?; } write!( f, "SECRET {if_exists}{name}", if_exists = if *if_exists { "IF EXISTS " } else { "" }, )?; if let Some(s) = storage_specifier { write!(f, " FROM {s}")?; } Ok(()) } Statement::DropPolicy(policy) => write!(f, "{policy}"), Statement::DropConnector { if_exists, name } => { write!( f, "DROP CONNECTOR {if_exists}{name}", if_exists = if *if_exists { "IF EXISTS " } else { "" } )?; Ok(()) } Statement::Discard { object_type } => { write!(f, "DISCARD {object_type}")?; Ok(()) } Self::Set(set) => write!(f, "{set}"), Statement::ShowVariable { variable } => { write!(f, "SHOW")?; if !variable.is_empty() { write!(f, " {}", display_separated(variable, " "))?; } Ok(()) } Statement::ShowStatus { filter, global, session, } => { write!(f, "SHOW")?; if *global { write!(f, " GLOBAL")?; } if *session { write!(f, " SESSION")?; } write!(f, " STATUS")?; if filter.is_some() { write!(f, " {}", filter.as_ref().unwrap())?; } Ok(()) } Statement::ShowVariables { filter, global, session, } => { write!(f, "SHOW")?; if *global { write!(f, " GLOBAL")?; } if *session { write!(f, " SESSION")?; } write!(f, " VARIABLES")?; if filter.is_some() { write!(f, " {}", filter.as_ref().unwrap())?; } Ok(()) } Statement::ShowCreate { obj_type, obj_name } => { write!(f, "SHOW CREATE {obj_type} {obj_name}",)?; Ok(()) } Statement::ShowColumns { extended, full, show_options, } => { write!( f, "SHOW {extended}{full}COLUMNS{show_options}", extended = if *extended { "EXTENDED " } else { "" }, full = if *full { "FULL " } else { "" }, )?; Ok(()) } Statement::ShowDatabases { terse, history, show_options, } => { write!( f, "SHOW {terse}DATABASES{history}{show_options}", terse = if *terse { "TERSE " } else { "" }, history = if *history { " HISTORY" } else { "" }, )?; Ok(()) } Statement::ShowCatalogs { terse, history, show_options, } => { write!( f, "SHOW {terse}CATALOGS{history}{show_options}", terse = if *terse { "TERSE " } else { "" }, history = if *history { " HISTORY" } else { "" }, )?; Ok(()) } Statement::ShowProcessList { full } => { write!( f, "SHOW {full}PROCESSLIST", full = if *full { "FULL " } else { "" }, )?; Ok(()) } Statement::ShowSchemas { terse, history, show_options, } => { write!( f, "SHOW {terse}SCHEMAS{history}{show_options}", terse = if *terse { "TERSE " } else { "" }, history = if *history { " HISTORY" } else { "" }, )?; Ok(()) } Statement::ShowObjects(ShowObjects { terse, show_options, }) => { write!( f, "SHOW {terse}OBJECTS{show_options}", terse = if *terse { "TERSE " } else { "" }, )?; Ok(()) } Statement::ShowTables { terse, history, extended, full, external, show_options, } => { write!( f, "SHOW {terse}{extended}{full}{external}TABLES{history}{show_options}", terse = if *terse { "TERSE " } else { "" }, extended = if *extended { "EXTENDED " } else { "" }, full = if *full { "FULL " } else { "" }, external = if *external { "EXTERNAL " } else { "" }, history = if *history { " HISTORY" } else { "" }, )?; Ok(()) } Statement::ShowViews { terse, materialized, show_options, } => { write!( f, "SHOW {terse}{materialized}VIEWS{show_options}", terse = if *terse { "TERSE " } else { "" }, materialized = if *materialized { "MATERIALIZED " } else { "" } )?; Ok(()) } Statement::ShowFunctions { filter } => { write!(f, "SHOW FUNCTIONS")?; if let Some(filter) = filter { write!(f, " {filter}")?; } Ok(()) } Statement::Use(use_expr) => use_expr.fmt(f), Statement::ShowCollation { filter } => { write!(f, "SHOW COLLATION")?; if let Some(filter) = filter { write!(f, " {filter}")?; } Ok(()) } Statement::ShowCharset(show_stm) => show_stm.fmt(f), Statement::StartTransaction { modes, begin: syntax_begin, transaction, modifier, statements, exception, has_end_keyword, } => { if *syntax_begin { if let Some(modifier) = *modifier { write!(f, "BEGIN {modifier}")?; } else { write!(f, "BEGIN")?; } } else { write!(f, "START")?; } if let Some(transaction) = transaction { write!(f, " {transaction}")?; } if !modes.is_empty() { write!(f, " {}", display_comma_separated(modes))?; } if !statements.is_empty() { write!(f, " ")?; format_statement_list(f, statements)?; } if let Some(exception_when) = exception { write!(f, " EXCEPTION")?; for when in exception_when { write!(f, " {when}")?; } } if *has_end_keyword { write!(f, " END")?; } Ok(()) } Statement::Commit { chain, end: end_syntax, modifier, } => { if *end_syntax { write!(f, "END")?; if let Some(modifier) = *modifier { write!(f, " {modifier}")?; } if *chain { write!(f, " AND CHAIN")?; } } else { write!(f, "COMMIT{}", if *chain { " AND CHAIN" } else { "" })?; } Ok(()) } Statement::Rollback { chain, savepoint } => { write!(f, "ROLLBACK")?; if *chain { write!(f, " AND CHAIN")?; } if let Some(savepoint) = savepoint { write!(f, " TO SAVEPOINT {savepoint}")?; } Ok(()) } Statement::CreateSchema { schema_name, if_not_exists, with, options, default_collate_spec, clone, } => { write!( f, "CREATE SCHEMA {if_not_exists}{name}", if_not_exists = if *if_not_exists { "IF NOT EXISTS " } else { "" }, name = schema_name )?; if let Some(collate) = default_collate_spec { write!(f, " DEFAULT COLLATE {collate}")?; } if let Some(with) = with { write!(f, " WITH ({})", display_comma_separated(with))?; } if let Some(options) = options { write!(f, " OPTIONS({})", display_comma_separated(options))?; } if let Some(clone) = clone { write!(f, " CLONE {clone}")?; } Ok(()) } Statement::Assert { condition, message } => { write!(f, "ASSERT {condition}")?; if let Some(m) = message { write!(f, " AS {m}")?; } Ok(()) } Statement::Grant(grant) => write!(f, "{grant}"), Statement::Deny(s) => write!(f, "{s}"), Statement::Revoke(revoke) => write!(f, "{revoke}"), Statement::Deallocate { name, prepare } => write!( f, "DEALLOCATE {prepare}{name}", prepare = if *prepare { "PREPARE " } else { "" }, name = name, ), Statement::Execute { name, parameters, has_parentheses, immediate, into, using, output, default, } => { let (open, close) = if *has_parentheses { // Space before `(` only when there is no name directly preceding it. (if name.is_some() { "(" } else { " (" }, ")") } else { (if parameters.is_empty() { "" } else { " " }, "") }; write!(f, "EXECUTE")?; if *immediate { write!(f, " IMMEDIATE")?; } if let Some(name) = name { write!(f, " {name}")?; } write!(f, "{open}{}{close}", display_comma_separated(parameters),)?; if !into.is_empty() { write!(f, " INTO {}", display_comma_separated(into))?; } if !using.is_empty() { write!(f, " USING {}", display_comma_separated(using))?; }; if *output { write!(f, " OUTPUT")?; } if *default { write!(f, " DEFAULT")?; } Ok(()) } Statement::Prepare { name, data_types, statement, } => { write!(f, "PREPARE {name} ")?; if !data_types.is_empty() { write!(f, "({}) ", display_comma_separated(data_types))?; } write!(f, "AS {statement}") } Statement::Comment { object_type, object_name, comment, if_exists, } => { write!(f, "COMMENT ")?; if *if_exists { write!(f, "IF EXISTS ")? }; write!(f, "ON {object_type} {object_name} IS ")?; if let Some(c) = comment { write!(f, "'{c}'") } else { write!(f, "NULL") } } Statement::Savepoint { name } => { write!(f, "SAVEPOINT ")?; write!(f, "{name}") } Statement::ReleaseSavepoint { name } => { write!(f, "RELEASE SAVEPOINT {name}") } Statement::Merge(merge) => merge.fmt(f), Statement::Cache { table_name, table_flag, has_as, options, query, } => { if let Some(table_flag) = table_flag { write!(f, "CACHE {table_flag} TABLE {table_name}")?; } else { write!(f, "CACHE TABLE {table_name}")?; } if !options.is_empty() { write!(f, " OPTIONS({})", display_comma_separated(options))?; } match (*has_as, query) { (true, Some(query)) => write!(f, " AS {query}"), (true, None) => f.write_str(" AS"), (false, Some(query)) => write!(f, " {query}"), (false, None) => Ok(()), } } Statement::UNCache { table_name, if_exists, } => { if *if_exists { write!(f, "UNCACHE TABLE IF EXISTS {table_name}") } else { write!(f, "UNCACHE TABLE {table_name}") } } Statement::CreateSequence { temporary, if_not_exists, name, data_type, sequence_options, owned_by, } => { let as_type: String = if let Some(dt) = data_type.as_ref() { //Cannot use format!(" AS {}", dt), due to format! is not available in --target thumbv6m-none-eabi // " AS ".to_owned() + &dt.to_string() [" AS ", &dt.to_string()].concat() } else { "".to_string() }; write!( f, "CREATE {temporary}SEQUENCE {if_not_exists}{name}{as_type}", if_not_exists = if *if_not_exists { "IF NOT EXISTS " } else { "" }, temporary = if *temporary { "TEMPORARY " } else { "" }, name = name, as_type = as_type )?; for sequence_option in sequence_options { write!(f, "{sequence_option}")?; } if let Some(ob) = owned_by.as_ref() { write!(f, " OWNED BY {ob}")?; } write!(f, "") } Statement::CreateStage { or_replace, temporary, if_not_exists, name, stage_params, directory_table_params, file_format, copy_options, comment, .. } => { write!( f, "CREATE {or_replace}{temp}STAGE {if_not_exists}{name}{stage_params}", temp = if *temporary { "TEMPORARY " } else { "" }, or_replace = if *or_replace { "OR REPLACE " } else { "" }, if_not_exists = if *if_not_exists { "IF NOT EXISTS " } else { "" }, )?; if !directory_table_params.options.is_empty() { write!(f, " DIRECTORY=({directory_table_params})")?; } if !file_format.options.is_empty() { write!(f, " FILE_FORMAT=({file_format})")?; } if !copy_options.options.is_empty() { write!(f, " COPY_OPTIONS=({copy_options})")?; } if comment.is_some() { write!(f, " COMMENT='{}'", comment.as_ref().unwrap())?; } Ok(()) } Statement::CopyIntoSnowflake { kind, into, into_columns, from_obj, from_obj_alias, stage_params, from_transformations, from_query, files, pattern, file_format, copy_options, validation_mode, partition, } => { write!(f, "COPY INTO {into}")?; if let Some(into_columns) = into_columns { write!(f, " ({})", display_comma_separated(into_columns))?; } if let Some(from_transformations) = from_transformations { // Data load with transformation if let Some(from_stage) = from_obj { write!( f, " FROM (SELECT {} FROM {}{}", display_separated(from_transformations, ", "), from_stage, stage_params )?; } if let Some(from_obj_alias) = from_obj_alias { write!(f, " AS {from_obj_alias}")?; } write!(f, ")")?; } else if let Some(from_obj) = from_obj { // Standard data load write!(f, " FROM {from_obj}{stage_params}")?; if let Some(from_obj_alias) = from_obj_alias { write!(f, " AS {from_obj_alias}")?; } } else if let Some(from_query) = from_query { // Data unload from query write!(f, " FROM ({from_query})")?; } if let Some(files) = files { write!(f, " FILES = ('{}')", display_separated(files, "', '"))?; } if let Some(pattern) = pattern { write!(f, " PATTERN = '{pattern}'")?; } if let Some(partition) = partition { write!(f, " PARTITION BY {partition}")?; } if !file_format.options.is_empty() { write!(f, " FILE_FORMAT=({file_format})")?; } if !copy_options.options.is_empty() { match kind { CopyIntoSnowflakeKind::Table => { write!(f, " COPY_OPTIONS=({copy_options})")? } CopyIntoSnowflakeKind::Location => write!(f, " {copy_options}")?, } } if let Some(validation_mode) = validation_mode { write!(f, " VALIDATION_MODE = {validation_mode}")?; } Ok(()) } Statement::CreateType { name, representation, } => { write!(f, "CREATE TYPE {name}")?; if let Some(repr) = representation { write!(f, " {repr}")?; } Ok(()) } Statement::Pragma { name, value, is_eq } => { write!(f, "PRAGMA {name}")?; if value.is_some() { let val = value.as_ref().unwrap(); if *is_eq { write!(f, " = {val}")?; } else { write!(f, "({val})")?; } } Ok(()) } Statement::Lock(lock) => lock.fmt(f), Statement::LockTables { tables } => { write!(f, "LOCK TABLES {}", display_comma_separated(tables)) } Statement::UnlockTables => { write!(f, "UNLOCK TABLES") } Statement::Unload { query, query_text, to, auth, with, options, } => { write!(f, "UNLOAD(")?; if let Some(query) = query { write!(f, "{query}")?; } if let Some(query_text) = query_text { write!(f, "'{query_text}'")?; } write!(f, ") TO {to}")?; if let Some(auth) = auth { write!(f, " IAM_ROLE {auth}")?; } if !with.is_empty() { write!(f, " WITH ({})", display_comma_separated(with))?; } if !options.is_empty() { write!(f, " {}", display_separated(options, " "))?; } Ok(()) } Statement::OptimizeTable { name, has_table_keyword, on_cluster, partition, include_final, deduplicate, predicate, zorder, } => { write!(f, "OPTIMIZE")?; if *has_table_keyword { write!(f, " TABLE")?; } write!(f, " {name}")?; if let Some(on_cluster) = on_cluster { write!(f, " ON CLUSTER {on_cluster}")?; } if let Some(partition) = partition { write!(f, " {partition}")?; } if *include_final { write!(f, " FINAL")?; } if let Some(deduplicate) = deduplicate { write!(f, " {deduplicate}")?; } if let Some(predicate) = predicate { write!(f, " WHERE {predicate}")?; } if let Some(zorder) = zorder { write!(f, " ZORDER BY ({})", display_comma_separated(zorder))?; } Ok(()) } Statement::LISTEN { channel } => { write!(f, "LISTEN {channel}")?; Ok(()) } Statement::UNLISTEN { channel } => { write!(f, "UNLISTEN {channel}")?; Ok(()) } Statement::NOTIFY { channel, payload } => { write!(f, "NOTIFY {channel}")?; if let Some(payload) = payload { write!(f, ", '{payload}'")?; } Ok(()) } Statement::RenameTable(rename_tables) => { write!(f, "RENAME TABLE {}", display_comma_separated(rename_tables)) } Statement::RaisError { message, severity, state, arguments, options, } => { write!(f, "RAISERROR({message}, {severity}, {state}")?; if !arguments.is_empty() { write!(f, ", {}", display_comma_separated(arguments))?; } write!(f, ")")?; if !options.is_empty() { write!(f, " WITH {}", display_comma_separated(options))?; } Ok(()) } Statement::Throw(s) => write!(f, "{s}"), Statement::Print(s) => write!(f, "{s}"), Statement::WaitFor(s) => write!(f, "{s}"), Statement::Return(r) => write!(f, "{r}"), Statement::List(command) => write!(f, "LIST {command}"), Statement::Remove(command) => write!(f, "REMOVE {command}"), Statement::ExportData(e) => write!(f, "{e}"), Statement::CreateUser(s) => write!(f, "{s}"), Statement::AlterSchema(s) => write!(f, "{s}"), Statement::Vacuum(s) => write!(f, "{s}"), Statement::AlterUser(s) => write!(f, "{s}"), Statement::Reset(s) => write!(f, "{s}"), } } } /// Can use to describe options in create sequence or table column type identity /// ```sql /// [ INCREMENT [ BY ] increment ] /// [ MINVALUE minvalue | NO MINVALUE ] [ MAXVALUE maxvalue | NO MAXVALUE ] /// [ START [ WITH ] start ] [ CACHE cache ] [ [ NO ] CYCLE ] /// ``` #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum SequenceOptions { /// `INCREMENT [BY] ` option; second value indicates presence of `BY` keyword. IncrementBy(Expr, bool), /// `MINVALUE ` or `NO MINVALUE`. MinValue(Option), /// `MAXVALUE ` or `NO MAXVALUE`. MaxValue(Option), /// `START [WITH] `; second value indicates presence of `WITH`. StartWith(Expr, bool), /// `CACHE ` option. Cache(Expr), /// `CYCLE` or `NO CYCLE` option. Cycle(bool), } impl fmt::Display for SequenceOptions { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { SequenceOptions::IncrementBy(increment, by) => { write!( f, " INCREMENT{by} {increment}", by = if *by { " BY" } else { "" }, increment = increment ) } SequenceOptions::MinValue(Some(expr)) => { write!(f, " MINVALUE {expr}") } SequenceOptions::MinValue(None) => { write!(f, " NO MINVALUE") } SequenceOptions::MaxValue(Some(expr)) => { write!(f, " MAXVALUE {expr}") } SequenceOptions::MaxValue(None) => { write!(f, " NO MAXVALUE") } SequenceOptions::StartWith(start, with) => { write!( f, " START{with} {start}", with = if *with { " WITH" } else { "" }, start = start ) } SequenceOptions::Cache(cache) => { write!(f, " CACHE {}", *cache) } SequenceOptions::Cycle(no) => { write!(f, " {}CYCLE", if *no { "NO " } else { "" }) } } } } /// Assignment for a `SET` statement (name [=|TO] value) #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct SetAssignment { /// Optional context scope (e.g., SESSION or LOCAL). pub scope: Option, /// Assignment target name. pub name: ObjectName, /// Assigned expression value. pub value: Expr, } impl fmt::Display for SetAssignment { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "{}{} = {}", self.scope.map(|s| format!("{s}")).unwrap_or_default(), self.name, self.value ) } } /// Target of a `TRUNCATE TABLE` command /// /// Note this is its own struct because `visit_relation` requires an `ObjectName` (not a `Vec`) #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] pub struct TruncateTableTarget { /// name of the table being truncated #[cfg_attr(feature = "visitor", visit(with = "visit_relation"))] pub name: ObjectName, /// Postgres-specific option: explicitly exclude descendants (also default without ONLY) /// ```sql /// TRUNCATE TABLE ONLY name /// ``` /// pub only: bool, /// Postgres-specific option: asterisk after table name to explicitly indicate descendants /// ```sql /// TRUNCATE TABLE name [ * ] /// ``` /// pub has_asterisk: bool, } impl fmt::Display for TruncateTableTarget { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { if self.only { write!(f, "ONLY ")?; }; write!(f, "{}", self.name)?; if self.has_asterisk { write!(f, " *")?; }; Ok(()) } } /// A `LOCK` statement. /// /// See #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] pub struct Lock { /// List of tables to lock. pub tables: Vec, /// Lock mode. pub lock_mode: Option, /// Whether `NOWAIT` was specified. pub nowait: bool, } impl fmt::Display for Lock { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "LOCK TABLE {}", display_comma_separated(&self.tables))?; if let Some(lock_mode) = &self.lock_mode { write!(f, " IN {lock_mode} MODE")?; } if self.nowait { write!(f, " NOWAIT")?; } Ok(()) } } /// Target of a `LOCK TABLE` command /// /// See #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] pub struct LockTableTarget { /// Name of the table being locked. #[cfg_attr(feature = "visitor", visit(with = "visit_relation"))] pub name: ObjectName, /// Whether `ONLY` was specified to exclude descendant tables. pub only: bool, /// Whether `*` was specified to explicitly include descendant tables. pub has_asterisk: bool, } impl fmt::Display for LockTableTarget { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { if self.only { write!(f, "ONLY ")?; } write!(f, "{}", self.name)?; if self.has_asterisk { write!(f, " *")?; } Ok(()) } } /// PostgreSQL lock modes for `LOCK TABLE`. /// /// See #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum LockTableMode { /// `ACCESS SHARE` AccessShare, /// `ROW SHARE` RowShare, /// `ROW EXCLUSIVE` RowExclusive, /// `SHARE UPDATE EXCLUSIVE` ShareUpdateExclusive, /// `SHARE` Share, /// `SHARE ROW EXCLUSIVE` ShareRowExclusive, /// `EXCLUSIVE` Exclusive, /// `ACCESS EXCLUSIVE` AccessExclusive, } impl fmt::Display for LockTableMode { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { let text = match self { Self::AccessShare => "ACCESS SHARE", Self::RowShare => "ROW SHARE", Self::RowExclusive => "ROW EXCLUSIVE", Self::ShareUpdateExclusive => "SHARE UPDATE EXCLUSIVE", Self::Share => "SHARE", Self::ShareRowExclusive => "SHARE ROW EXCLUSIVE", Self::Exclusive => "EXCLUSIVE", Self::AccessExclusive => "ACCESS EXCLUSIVE", }; write!(f, "{text}") } } /// PostgreSQL identity option for TRUNCATE table /// [ RESTART IDENTITY | CONTINUE IDENTITY ] #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum TruncateIdentityOption { /// Restart identity values (RESTART IDENTITY). Restart, /// Continue identity values (CONTINUE IDENTITY). Continue, } /// Cascade/restrict option for Postgres TRUNCATE table, MySQL GRANT/REVOKE, etc. /// [ CASCADE | RESTRICT ] #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum CascadeOption { /// Apply cascading action (e.g., CASCADE). Cascade, /// Restrict the action (e.g., RESTRICT). Restrict, } impl Display for CascadeOption { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { CascadeOption::Cascade => write!(f, "CASCADE"), CascadeOption::Restrict => write!(f, "RESTRICT"), } } } /// Transaction started with [ TRANSACTION | WORK | TRAN ] #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum BeginTransactionKind { /// Standard `TRANSACTION` keyword. Transaction, /// Alternate `WORK` keyword. Work, /// MSSQL shorthand `TRAN` keyword. /// See Tran, } impl Display for BeginTransactionKind { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { BeginTransactionKind::Transaction => write!(f, "TRANSACTION"), BeginTransactionKind::Work => write!(f, "WORK"), BeginTransactionKind::Tran => write!(f, "TRAN"), } } } /// Can use to describe options in create sequence or table column type identity /// [ MINVALUE minvalue | NO MINVALUE ] [ MAXVALUE maxvalue | NO MAXVALUE ] #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum MinMaxValue { /// Clause is not specified. Empty, /// NO MINVALUE / NO MAXVALUE. None, /// `MINVALUE ` / `MAXVALUE `. Some(Expr), } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] #[non_exhaustive] /// Behavior to apply for `INSERT` when a conflict occurs. pub enum OnInsert { /// ON DUPLICATE KEY UPDATE (MySQL when the key already exists, then execute an update instead) DuplicateKeyUpdate(Vec), /// ON CONFLICT is a PostgreSQL and Sqlite extension OnConflict(OnConflict), } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Optional aliases for `INSERT` targets: row alias and optional column aliases. pub struct InsertAliases { /// Row alias (table-style alias) for the inserted values. pub row_alias: ObjectName, /// Optional list of column aliases for the inserted values. pub col_aliases: Option>, } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Optional alias for an `INSERT` table; i.e. the table to be inserted into pub struct TableAliasWithoutColumns { /// `true` if the aliases was explicitly introduced with the "AS" keyword pub explicit: bool, /// the alias name itself pub alias: Ident, } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// `ON CONFLICT` clause representation. pub struct OnConflict { /// Optional conflict target specifying columns or constraint. pub conflict_target: Option, /// Action to take when a conflict occurs. pub action: OnConflictAction, } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Target specification for an `ON CONFLICT` clause. pub enum ConflictTarget { /// Target specified as a list of columns. Columns(Vec), /// Target specified as a named constraint. OnConstraint(ObjectName), } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Action to perform when an `ON CONFLICT` target is matched. pub enum OnConflictAction { /// Do nothing on conflict. DoNothing, /// Perform an update on conflict. DoUpdate(DoUpdate), } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Details for `DO UPDATE` action of an `ON CONFLICT` clause. pub struct DoUpdate { /// Column assignments to perform on update. pub assignments: Vec, /// Optional WHERE clause limiting the update. pub selection: Option, } impl fmt::Display for OnInsert { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { Self::DuplicateKeyUpdate(expr) => write!( f, " ON DUPLICATE KEY UPDATE {}", display_comma_separated(expr) ), Self::OnConflict(o) => write!(f, "{o}"), } } } impl fmt::Display for OnConflict { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, " ON CONFLICT")?; if let Some(target) = &self.conflict_target { write!(f, "{target}")?; } write!(f, " {}", self.action) } } impl fmt::Display for ConflictTarget { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { ConflictTarget::Columns(cols) => write!(f, "({})", display_comma_separated(cols)), ConflictTarget::OnConstraint(name) => write!(f, " ON CONSTRAINT {name}"), } } } impl fmt::Display for OnConflictAction { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { Self::DoNothing => write!(f, "DO NOTHING"), Self::DoUpdate(do_update) => { write!(f, "DO UPDATE")?; if !do_update.assignments.is_empty() { write!( f, " SET {}", display_comma_separated(&do_update.assignments) )?; } if let Some(selection) = &do_update.selection { write!(f, " WHERE {selection}")?; } Ok(()) } } } } /// Privileges granted in a GRANT statement or revoked in a REVOKE statement. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum Privileges { /// All privileges applicable to the object type All { /// Optional keyword from the spec, ignored in practice with_privileges_keyword: bool, }, /// Specific privileges (e.g. `SELECT`, `INSERT`) Actions(Vec), } impl fmt::Display for Privileges { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { Privileges::All { with_privileges_keyword, } => { write!( f, "ALL{}", if *with_privileges_keyword { " PRIVILEGES" } else { "" } ) } Privileges::Actions(actions) => { write!(f, "{}", display_comma_separated(actions)) } } } } /// Specific direction for FETCH statement #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum FetchDirection { /// Fetch a specific count of rows. Count { /// The limit value for the count. limit: ValueWithSpan, }, /// Fetch the next row. Next, /// Fetch the prior row. Prior, /// Fetch the first row. First, /// Fetch the last row. Last, /// Fetch an absolute row by index. Absolute { /// The absolute index value. limit: ValueWithSpan, }, /// Fetch a row relative to the current position. Relative { /// The relative offset value. limit: ValueWithSpan, }, /// Fetch all rows. All, // FORWARD // FORWARD count /// Fetch forward by an optional limit. Forward { /// Optional forward limit. limit: Option, }, /// Fetch all forward rows. ForwardAll, // BACKWARD // BACKWARD count /// Fetch backward by an optional limit. Backward { /// Optional backward limit. limit: Option, }, /// Fetch all backward rows. BackwardAll, } impl fmt::Display for FetchDirection { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { FetchDirection::Count { limit } => f.write_str(&limit.to_string())?, FetchDirection::Next => f.write_str("NEXT")?, FetchDirection::Prior => f.write_str("PRIOR")?, FetchDirection::First => f.write_str("FIRST")?, FetchDirection::Last => f.write_str("LAST")?, FetchDirection::Absolute { limit } => { f.write_str("ABSOLUTE ")?; f.write_str(&limit.to_string())?; } FetchDirection::Relative { limit } => { f.write_str("RELATIVE ")?; f.write_str(&limit.to_string())?; } FetchDirection::All => f.write_str("ALL")?, FetchDirection::Forward { limit } => { f.write_str("FORWARD")?; if let Some(l) = limit { f.write_str(" ")?; f.write_str(&l.to_string())?; } } FetchDirection::ForwardAll => f.write_str("FORWARD ALL")?, FetchDirection::Backward { limit } => { f.write_str("BACKWARD")?; if let Some(l) = limit { f.write_str(" ")?; f.write_str(&l.to_string())?; } } FetchDirection::BackwardAll => f.write_str("BACKWARD ALL")?, }; Ok(()) } } /// The "position" for a FETCH statement. /// /// [MsSql](https://learn.microsoft.com/en-us/sql/t-sql/language-elements/fetch-transact-sql) #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum FetchPosition { /// Use `FROM ` position specifier. From, /// Use `IN ` position specifier. In, } impl fmt::Display for FetchPosition { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { FetchPosition::From => f.write_str("FROM")?, FetchPosition::In => f.write_str("IN")?, }; Ok(()) } } /// A privilege on a database object (table, sequence, etc.). #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum Action { /// Add a search optimization. AddSearchOptimization, /// Apply an `APPLY` operation with a specific type. Apply { /// The type of apply operation. apply_type: ActionApplyType, }, /// Apply a budget operation. ApplyBudget, /// Attach a listing. AttachListing, /// Attach a policy. AttachPolicy, /// Audit operation. Audit, /// Bind a service endpoint. BindServiceEndpoint, /// Connect permission. Connect, /// Create action, optionally specifying an object type. Create { /// Optional object type to create. obj_type: Option, }, /// Actions related to database roles. DatabaseRole { /// The role name. role: ObjectName, }, /// Delete permission. Delete, /// Drop permission. Drop, /// Evolve schema permission. EvolveSchema, /// Exec action (execute) with optional object type. Exec { /// Optional execute object type. obj_type: Option, }, /// Execute action with optional object type. Execute { /// Optional execute object type. obj_type: Option, }, /// Failover operation. Failover, /// Use imported privileges. ImportedPrivileges, /// Import a share. ImportShare, /// Insert rows with optional column list. Insert { /// Optional list of target columns for insert. columns: Option>, }, /// Manage operation with a specific manage type. Manage { /// The specific manage sub-type. manage_type: ActionManageType, }, /// Manage releases. ManageReleases, /// Manage versions. ManageVersions, /// Modify operation with an optional modify type. Modify { /// The optional modify sub-type. modify_type: Option, }, /// Monitor operation with an optional monitor type. Monitor { /// The optional monitor sub-type. monitor_type: Option, }, /// Operate permission. Operate, /// Override share restrictions. OverrideShareRestrictions, /// Ownership permission. Ownership, /// Purchase a data exchange listing. PurchaseDataExchangeListing, /// Read access. Read, /// Read session-level access. ReadSession, /// References with optional column list. References { /// Optional list of referenced column identifiers. columns: Option>, }, /// Replication permission. Replicate, /// Resolve all references. ResolveAll, /// Role-related permission with target role name. Role { /// The target role name. role: ObjectName, }, /// Select permission with optional column list. Select { /// Optional list of selected columns. columns: Option>, }, /// Temporary object permission. Temporary, /// Trigger-related permission. Trigger, /// Truncate permission. Truncate, /// Update permission with optional affected columns. Update { /// Optional list of columns affected by update. columns: Option>, }, /// Usage permission. Usage, } impl fmt::Display for Action { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { Action::AddSearchOptimization => f.write_str("ADD SEARCH OPTIMIZATION")?, Action::Apply { apply_type } => write!(f, "APPLY {apply_type}")?, Action::ApplyBudget => f.write_str("APPLYBUDGET")?, Action::AttachListing => f.write_str("ATTACH LISTING")?, Action::AttachPolicy => f.write_str("ATTACH POLICY")?, Action::Audit => f.write_str("AUDIT")?, Action::BindServiceEndpoint => f.write_str("BIND SERVICE ENDPOINT")?, Action::Connect => f.write_str("CONNECT")?, Action::Create { obj_type } => { f.write_str("CREATE")?; if let Some(obj_type) = obj_type { write!(f, " {obj_type}")? } } Action::DatabaseRole { role } => write!(f, "DATABASE ROLE {role}")?, Action::Delete => f.write_str("DELETE")?, Action::Drop => f.write_str("DROP")?, Action::EvolveSchema => f.write_str("EVOLVE SCHEMA")?, Action::Exec { obj_type } => { f.write_str("EXEC")?; if let Some(obj_type) = obj_type { write!(f, " {obj_type}")? } } Action::Execute { obj_type } => { f.write_str("EXECUTE")?; if let Some(obj_type) = obj_type { write!(f, " {obj_type}")? } } Action::Failover => f.write_str("FAILOVER")?, Action::ImportedPrivileges => f.write_str("IMPORTED PRIVILEGES")?, Action::ImportShare => f.write_str("IMPORT SHARE")?, Action::Insert { .. } => f.write_str("INSERT")?, Action::Manage { manage_type } => write!(f, "MANAGE {manage_type}")?, Action::ManageReleases => f.write_str("MANAGE RELEASES")?, Action::ManageVersions => f.write_str("MANAGE VERSIONS")?, Action::Modify { modify_type } => { write!(f, "MODIFY")?; if let Some(modify_type) = modify_type { write!(f, " {modify_type}")?; } } Action::Monitor { monitor_type } => { write!(f, "MONITOR")?; if let Some(monitor_type) = monitor_type { write!(f, " {monitor_type}")? } } Action::Operate => f.write_str("OPERATE")?, Action::OverrideShareRestrictions => f.write_str("OVERRIDE SHARE RESTRICTIONS")?, Action::Ownership => f.write_str("OWNERSHIP")?, Action::PurchaseDataExchangeListing => f.write_str("PURCHASE DATA EXCHANGE LISTING")?, Action::Read => f.write_str("READ")?, Action::ReadSession => f.write_str("READ SESSION")?, Action::References { .. } => f.write_str("REFERENCES")?, Action::Replicate => f.write_str("REPLICATE")?, Action::ResolveAll => f.write_str("RESOLVE ALL")?, Action::Role { role } => write!(f, "ROLE {role}")?, Action::Select { .. } => f.write_str("SELECT")?, Action::Temporary => f.write_str("TEMPORARY")?, Action::Trigger => f.write_str("TRIGGER")?, Action::Truncate => f.write_str("TRUNCATE")?, Action::Update { .. } => f.write_str("UPDATE")?, Action::Usage => f.write_str("USAGE")?, }; match self { Action::Insert { columns } | Action::References { columns } | Action::Select { columns } | Action::Update { columns } => { if let Some(columns) = columns { write!(f, " ({})", display_comma_separated(columns))?; } } _ => (), }; Ok(()) } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// See /// under `globalPrivileges` in the `CREATE` privilege. pub enum ActionCreateObjectType { /// An account-level object. Account, /// An application object. Application, /// An application package object. ApplicationPackage, /// A compute pool object. ComputePool, /// A data exchange listing. DataExchangeListing, /// A database object. Database, /// An external volume object. ExternalVolume, /// A failover group object. FailoverGroup, /// An integration object. Integration, /// A network policy object. NetworkPolicy, /// An organization listing. OrganiationListing, /// A replication group object. ReplicationGroup, /// A role object. Role, /// A schema object. Schema, /// A share object. Share, /// A user object. User, /// A warehouse object. Warehouse, } impl fmt::Display for ActionCreateObjectType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { ActionCreateObjectType::Account => write!(f, "ACCOUNT"), ActionCreateObjectType::Application => write!(f, "APPLICATION"), ActionCreateObjectType::ApplicationPackage => write!(f, "APPLICATION PACKAGE"), ActionCreateObjectType::ComputePool => write!(f, "COMPUTE POOL"), ActionCreateObjectType::DataExchangeListing => write!(f, "DATA EXCHANGE LISTING"), ActionCreateObjectType::Database => write!(f, "DATABASE"), ActionCreateObjectType::ExternalVolume => write!(f, "EXTERNAL VOLUME"), ActionCreateObjectType::FailoverGroup => write!(f, "FAILOVER GROUP"), ActionCreateObjectType::Integration => write!(f, "INTEGRATION"), ActionCreateObjectType::NetworkPolicy => write!(f, "NETWORK POLICY"), ActionCreateObjectType::OrganiationListing => write!(f, "ORGANIZATION LISTING"), ActionCreateObjectType::ReplicationGroup => write!(f, "REPLICATION GROUP"), ActionCreateObjectType::Role => write!(f, "ROLE"), ActionCreateObjectType::Schema => write!(f, "SCHEMA"), ActionCreateObjectType::Share => write!(f, "SHARE"), ActionCreateObjectType::User => write!(f, "USER"), ActionCreateObjectType::Warehouse => write!(f, "WAREHOUSE"), } } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// See /// under `globalPrivileges` in the `APPLY` privilege. pub enum ActionApplyType { /// Apply an aggregation policy. AggregationPolicy, /// Apply an authentication policy. AuthenticationPolicy, /// Apply a join policy. JoinPolicy, /// Apply a masking policy. MaskingPolicy, /// Apply a packages policy. PackagesPolicy, /// Apply a password policy. PasswordPolicy, /// Apply a projection policy. ProjectionPolicy, /// Apply a row access policy. RowAccessPolicy, /// Apply a session policy. SessionPolicy, /// Apply a tag. Tag, } impl fmt::Display for ActionApplyType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { ActionApplyType::AggregationPolicy => write!(f, "AGGREGATION POLICY"), ActionApplyType::AuthenticationPolicy => write!(f, "AUTHENTICATION POLICY"), ActionApplyType::JoinPolicy => write!(f, "JOIN POLICY"), ActionApplyType::MaskingPolicy => write!(f, "MASKING POLICY"), ActionApplyType::PackagesPolicy => write!(f, "PACKAGES POLICY"), ActionApplyType::PasswordPolicy => write!(f, "PASSWORD POLICY"), ActionApplyType::ProjectionPolicy => write!(f, "PROJECTION POLICY"), ActionApplyType::RowAccessPolicy => write!(f, "ROW ACCESS POLICY"), ActionApplyType::SessionPolicy => write!(f, "SESSION POLICY"), ActionApplyType::Tag => write!(f, "TAG"), } } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// See /// under `globalPrivileges` in the `EXECUTE` privilege. pub enum ActionExecuteObjectType { /// Alert object. Alert, /// Data metric function object. DataMetricFunction, /// Managed alert object. ManagedAlert, /// Managed task object. ManagedTask, /// Task object. Task, } impl fmt::Display for ActionExecuteObjectType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { ActionExecuteObjectType::Alert => write!(f, "ALERT"), ActionExecuteObjectType::DataMetricFunction => write!(f, "DATA METRIC FUNCTION"), ActionExecuteObjectType::ManagedAlert => write!(f, "MANAGED ALERT"), ActionExecuteObjectType::ManagedTask => write!(f, "MANAGED TASK"), ActionExecuteObjectType::Task => write!(f, "TASK"), } } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// See /// under `globalPrivileges` in the `MANAGE` privilege. pub enum ActionManageType { /// Account support cases management. AccountSupportCases, /// Event sharing management. EventSharing, /// Grants management. Grants, /// Listing auto-fulfillment management. ListingAutoFulfillment, /// Organization support cases management. OrganizationSupportCases, /// User support cases management. UserSupportCases, /// Warehouses management. Warehouses, } impl fmt::Display for ActionManageType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { ActionManageType::AccountSupportCases => write!(f, "ACCOUNT SUPPORT CASES"), ActionManageType::EventSharing => write!(f, "EVENT SHARING"), ActionManageType::Grants => write!(f, "GRANTS"), ActionManageType::ListingAutoFulfillment => write!(f, "LISTING AUTO FULFILLMENT"), ActionManageType::OrganizationSupportCases => write!(f, "ORGANIZATION SUPPORT CASES"), ActionManageType::UserSupportCases => write!(f, "USER SUPPORT CASES"), ActionManageType::Warehouses => write!(f, "WAREHOUSES"), } } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// See /// under `globalPrivileges` in the `MODIFY` privilege. pub enum ActionModifyType { /// Modify log level. LogLevel, /// Modify trace level. TraceLevel, /// Modify session log level. SessionLogLevel, /// Modify session trace level. SessionTraceLevel, } impl fmt::Display for ActionModifyType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { ActionModifyType::LogLevel => write!(f, "LOG LEVEL"), ActionModifyType::TraceLevel => write!(f, "TRACE LEVEL"), ActionModifyType::SessionLogLevel => write!(f, "SESSION LOG LEVEL"), ActionModifyType::SessionTraceLevel => write!(f, "SESSION TRACE LEVEL"), } } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// See /// under `globalPrivileges` in the `MONITOR` privilege. pub enum ActionMonitorType { /// Monitor execution. Execution, /// Monitor security. Security, /// Monitor usage. Usage, } impl fmt::Display for ActionMonitorType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { ActionMonitorType::Execution => write!(f, "EXECUTION"), ActionMonitorType::Security => write!(f, "SECURITY"), ActionMonitorType::Usage => write!(f, "USAGE"), } } } /// The principal that receives the privileges #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct Grantee { /// The category/type of grantee (role, user, share, etc.). pub grantee_type: GranteesType, /// Optional name of the grantee (identifier or user@host). pub name: Option, } impl fmt::Display for Grantee { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self.grantee_type { GranteesType::Role => { write!(f, "ROLE ")?; } GranteesType::Share => { write!(f, "SHARE ")?; } GranteesType::User => { write!(f, "USER ")?; } GranteesType::Group => { write!(f, "GROUP ")?; } GranteesType::Public => { write!(f, "PUBLIC ")?; } GranteesType::DatabaseRole => { write!(f, "DATABASE ROLE ")?; } GranteesType::Application => { write!(f, "APPLICATION ")?; } GranteesType::ApplicationRole => { write!(f, "APPLICATION ROLE ")?; } GranteesType::None => (), } if let Some(ref name) = self.name { name.fmt(f)?; } Ok(()) } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// The kind of principal receiving privileges. pub enum GranteesType { /// A role principal. Role, /// A share principal. Share, /// A user principal. User, /// A group principal. Group, /// The public principal. Public, /// A database role principal. DatabaseRole, /// An application principal. Application, /// An application role principal. ApplicationRole, /// No specific principal (e.g. `NONE`). None, } /// Users/roles designated in a GRANT/REVOKE #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum GranteeName { /// A bare identifier ObjectName(ObjectName), /// A MySQL user/host pair such as 'root'@'%' UserHost { /// The user identifier portion. user: Ident, /// The host identifier portion. host: Ident, }, } impl fmt::Display for GranteeName { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { GranteeName::ObjectName(name) => name.fmt(f), GranteeName::UserHost { user, host } => { write!(f, "{user}@{host}") } } } } /// Objects on which privileges are granted in a GRANT statement. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum GrantObjects { /// Grant privileges on `ALL SEQUENCES IN SCHEMA [, ...]` AllSequencesInSchema { /// The target schema names. schemas: Vec, }, /// Grant privileges on `ALL TABLES IN SCHEMA [, ...]` AllTablesInSchema { /// The target schema names. schemas: Vec, }, /// Grant privileges on `ALL VIEWS IN SCHEMA [, ...]` AllViewsInSchema { /// The target schema names. schemas: Vec, }, /// Grant privileges on `ALL MATERIALIZED VIEWS IN SCHEMA [, ...]` AllMaterializedViewsInSchema { /// The target schema names. schemas: Vec, }, /// Grant privileges on `ALL EXTERNAL TABLES IN SCHEMA [, ...]` AllExternalTablesInSchema { /// The target schema names. schemas: Vec, }, /// Grant privileges on `ALL FUNCTIONS IN SCHEMA [, ...]` AllFunctionsInSchema { /// The target schema names. schemas: Vec, }, /// Grant privileges on `FUTURE SCHEMAS IN DATABASE [, ...]` FutureSchemasInDatabase { /// The target database names. databases: Vec, }, /// Grant privileges on `FUTURE TABLES IN SCHEMA [, ...]` FutureTablesInSchema { /// The target schema names. schemas: Vec, }, /// Grant privileges on `FUTURE VIEWS IN SCHEMA [, ...]` FutureViewsInSchema { /// The target schema names. schemas: Vec, }, /// Grant privileges on `FUTURE EXTERNAL TABLES IN SCHEMA [, ...]` FutureExternalTablesInSchema { /// The target schema names. schemas: Vec, }, /// Grant privileges on `FUTURE MATERIALIZED VIEWS IN SCHEMA [, ...]` FutureMaterializedViewsInSchema { /// The target schema names. schemas: Vec, }, /// Grant privileges on `FUTURE SEQUENCES IN SCHEMA [, ...]` FutureSequencesInSchema { /// The target schema names. schemas: Vec, }, /// Grant privileges on specific databases Databases(Vec), /// Grant privileges on specific schemas Schemas(Vec), /// Grant privileges on specific sequences Sequences(Vec), /// Grant privileges on specific tables Tables(Vec), /// Grant privileges on specific views Views(Vec), /// Grant privileges on specific warehouses Warehouses(Vec), /// Grant privileges on specific integrations Integrations(Vec), /// Grant privileges on resource monitors ResourceMonitors(Vec), /// Grant privileges on users Users(Vec), /// Grant privileges on compute pools ComputePools(Vec), /// Grant privileges on connections Connections(Vec), /// Grant privileges on failover groups FailoverGroup(Vec), /// Grant privileges on replication group ReplicationGroup(Vec), /// Grant privileges on external volumes ExternalVolumes(Vec), /// Grant privileges on a procedure. In dialects that /// support overloading, the argument types must be specified. /// /// For example: /// `GRANT USAGE ON PROCEDURE foo(varchar) TO ROLE role1` Procedure { /// The procedure name. name: ObjectName, /// Optional argument types for overloaded procedures. arg_types: Vec, }, /// Grant privileges on a function. In dialects that /// support overloading, the argument types must be specified. /// /// For example: /// `GRANT USAGE ON FUNCTION foo(varchar) TO ROLE role1` Function { /// The function name. name: ObjectName, /// Optional argument types for overloaded functions. arg_types: Vec, }, } impl fmt::Display for GrantObjects { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { GrantObjects::Sequences(sequences) => { write!(f, "SEQUENCE {}", display_comma_separated(sequences)) } GrantObjects::Databases(databases) => { write!(f, "DATABASE {}", display_comma_separated(databases)) } GrantObjects::Schemas(schemas) => { write!(f, "SCHEMA {}", display_comma_separated(schemas)) } GrantObjects::Tables(tables) => { write!(f, "{}", display_comma_separated(tables)) } GrantObjects::Views(views) => { write!(f, "VIEW {}", display_comma_separated(views)) } GrantObjects::Warehouses(warehouses) => { write!(f, "WAREHOUSE {}", display_comma_separated(warehouses)) } GrantObjects::Integrations(integrations) => { write!(f, "INTEGRATION {}", display_comma_separated(integrations)) } GrantObjects::AllSequencesInSchema { schemas } => { write!( f, "ALL SEQUENCES IN SCHEMA {}", display_comma_separated(schemas) ) } GrantObjects::AllTablesInSchema { schemas } => { write!( f, "ALL TABLES IN SCHEMA {}", display_comma_separated(schemas) ) } GrantObjects::AllExternalTablesInSchema { schemas } => { write!( f, "ALL EXTERNAL TABLES IN SCHEMA {}", display_comma_separated(schemas) ) } GrantObjects::AllViewsInSchema { schemas } => { write!( f, "ALL VIEWS IN SCHEMA {}", display_comma_separated(schemas) ) } GrantObjects::AllMaterializedViewsInSchema { schemas } => { write!( f, "ALL MATERIALIZED VIEWS IN SCHEMA {}", display_comma_separated(schemas) ) } GrantObjects::AllFunctionsInSchema { schemas } => { write!( f, "ALL FUNCTIONS IN SCHEMA {}", display_comma_separated(schemas) ) } GrantObjects::FutureSchemasInDatabase { databases } => { write!( f, "FUTURE SCHEMAS IN DATABASE {}", display_comma_separated(databases) ) } GrantObjects::FutureTablesInSchema { schemas } => { write!( f, "FUTURE TABLES IN SCHEMA {}", display_comma_separated(schemas) ) } GrantObjects::FutureExternalTablesInSchema { schemas } => { write!( f, "FUTURE EXTERNAL TABLES IN SCHEMA {}", display_comma_separated(schemas) ) } GrantObjects::FutureViewsInSchema { schemas } => { write!( f, "FUTURE VIEWS IN SCHEMA {}", display_comma_separated(schemas) ) } GrantObjects::FutureMaterializedViewsInSchema { schemas } => { write!( f, "FUTURE MATERIALIZED VIEWS IN SCHEMA {}", display_comma_separated(schemas) ) } GrantObjects::FutureSequencesInSchema { schemas } => { write!( f, "FUTURE SEQUENCES IN SCHEMA {}", display_comma_separated(schemas) ) } GrantObjects::ResourceMonitors(objects) => { write!(f, "RESOURCE MONITOR {}", display_comma_separated(objects)) } GrantObjects::Users(objects) => { write!(f, "USER {}", display_comma_separated(objects)) } GrantObjects::ComputePools(objects) => { write!(f, "COMPUTE POOL {}", display_comma_separated(objects)) } GrantObjects::Connections(objects) => { write!(f, "CONNECTION {}", display_comma_separated(objects)) } GrantObjects::FailoverGroup(objects) => { write!(f, "FAILOVER GROUP {}", display_comma_separated(objects)) } GrantObjects::ReplicationGroup(objects) => { write!(f, "REPLICATION GROUP {}", display_comma_separated(objects)) } GrantObjects::ExternalVolumes(objects) => { write!(f, "EXTERNAL VOLUME {}", display_comma_separated(objects)) } GrantObjects::Procedure { name, arg_types } => { write!(f, "PROCEDURE {name}")?; if !arg_types.is_empty() { write!(f, "({})", display_comma_separated(arg_types))?; } Ok(()) } GrantObjects::Function { name, arg_types } => { write!(f, "FUNCTION {name}")?; if !arg_types.is_empty() { write!(f, "({})", display_comma_separated(arg_types))?; } Ok(()) } } } } /// A `DENY` statement /// /// [MsSql](https://learn.microsoft.com/en-us/sql/t-sql/statements/deny-transact-sql) #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct DenyStatement { /// The privileges to deny. pub privileges: Privileges, /// The objects the privileges apply to. pub objects: GrantObjects, /// The grantees (users/roles) to whom the denial applies. pub grantees: Vec, /// Optional identifier of the principal that performed the grant. pub granted_by: Option, /// Optional cascade option controlling dependent objects. pub cascade: Option, } impl fmt::Display for DenyStatement { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "DENY {}", self.privileges)?; write!(f, " ON {}", self.objects)?; if !self.grantees.is_empty() { write!(f, " TO {}", display_comma_separated(&self.grantees))?; } if let Some(cascade) = &self.cascade { write!(f, " {cascade}")?; } if let Some(granted_by) = &self.granted_by { write!(f, " AS {granted_by}")?; } Ok(()) } } /// SQL assignment `foo = expr` as used in SQLUpdate #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct Assignment { /// The left-hand side of the assignment. pub target: AssignmentTarget, /// The expression assigned to the target. pub value: Expr, } impl fmt::Display for Assignment { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{} = {}", self.target, self.value) } } /// Left-hand side of an assignment in an UPDATE statement, /// e.g. `foo` in `foo = 5` (ColumnName assignment) or /// `(a, b)` in `(a, b) = (1, 2)` (Tuple assignment). #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum AssignmentTarget { /// A single column ColumnName(ObjectName), /// A tuple of columns Tuple(Vec), } impl fmt::Display for AssignmentTarget { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { AssignmentTarget::ColumnName(column) => write!(f, "{column}"), AssignmentTarget::Tuple(columns) => write!(f, "({})", display_comma_separated(columns)), } } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Expression forms allowed as a function argument. pub enum FunctionArgExpr { /// A normal expression argument. Expr(Expr), /// Qualified wildcard, e.g. `alias.*` or `schema.table.*`. QualifiedWildcard(ObjectName), /// An unqualified `*` wildcard. Wildcard, /// An unqualified `*` wildcard with additional options, e.g. `* EXCLUDE(col)`. /// /// Used in Snowflake to support expressions like `HASH(* EXCLUDE(col))`. WildcardWithOptions(WildcardAdditionalOptions), } impl From for FunctionArgExpr { fn from(wildcard_expr: Expr) -> Self { match wildcard_expr { Expr::QualifiedWildcard(prefix, _) => Self::QualifiedWildcard(prefix), Expr::Wildcard(_) => Self::Wildcard, expr => Self::Expr(expr), } } } impl fmt::Display for FunctionArgExpr { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { FunctionArgExpr::Expr(expr) => write!(f, "{expr}"), FunctionArgExpr::QualifiedWildcard(prefix) => write!(f, "{prefix}.*"), FunctionArgExpr::Wildcard => f.write_str("*"), FunctionArgExpr::WildcardWithOptions(opts) => write!(f, "*{opts}"), } } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Operator used to separate function arguments pub enum FunctionArgOperator { /// function(arg1 = value1) Equals, /// function(arg1 => value1) RightArrow, /// function(arg1 := value1) Assignment, /// function(arg1 : value1) Colon, /// function(arg1 VALUE value1) Value, } impl fmt::Display for FunctionArgOperator { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { FunctionArgOperator::Equals => f.write_str("="), FunctionArgOperator::RightArrow => f.write_str("=>"), FunctionArgOperator::Assignment => f.write_str(":="), FunctionArgOperator::Colon => f.write_str(":"), FunctionArgOperator::Value => f.write_str("VALUE"), } } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Forms of function arguments (named, expression-named, or positional). pub enum FunctionArg { /// `name` is identifier /// /// Enabled when `Dialect::supports_named_fn_args_with_expr_name` returns 'false' Named { /// The identifier name of the argument. name: Ident, /// The argument expression or wildcard form. arg: FunctionArgExpr, /// The operator separating name and value. operator: FunctionArgOperator, }, /// `name` is arbitrary expression /// /// Enabled when `Dialect::supports_named_fn_args_with_expr_name` returns 'true' ExprNamed { /// The expression used as the argument name. name: Expr, /// The argument expression or wildcard form. arg: FunctionArgExpr, /// The operator separating name and value. operator: FunctionArgOperator, }, /// An unnamed argument (positional), given by expression or wildcard. Unnamed(FunctionArgExpr), } impl fmt::Display for FunctionArg { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { FunctionArg::Named { name, arg, operator, } => write!(f, "{name} {operator} {arg}"), FunctionArg::ExprNamed { name, arg, operator, } => write!(f, "{name} {operator} {arg}"), FunctionArg::Unnamed(unnamed_arg) => write!(f, "{unnamed_arg}"), } } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Which cursor(s) to close. pub enum CloseCursor { /// Close all cursors. All, /// Close a specific cursor by name. Specific { /// The name of the cursor to close. name: Ident, }, } impl fmt::Display for CloseCursor { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { CloseCursor::All => write!(f, "ALL"), CloseCursor::Specific { name } => write!(f, "{name}"), } } } /// A Drop Domain statement #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct DropDomain { /// Whether to drop the domain if it exists pub if_exists: bool, /// The name of the domain to drop pub name: ObjectName, /// The behavior to apply when dropping the domain pub drop_behavior: Option, } /// A constant of form ` 'value'`. /// This can represent ANSI SQL `DATE`, `TIME`, and `TIMESTAMP` literals (such as `DATE '2020-01-01'`), /// as well as constants of other types (a non-standard PostgreSQL extension). #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct TypedString { /// The data type of the typed string (e.g. DATE, TIME, TIMESTAMP). pub data_type: DataType, /// The value of the constant. /// Hint: you can unwrap the string value using `value.into_string()`. pub value: ValueWithSpan, /// Flags whether this TypedString uses the [ODBC syntax]. /// /// Example: /// ```sql /// -- An ODBC date literal: /// SELECT {d '2025-07-16'} /// -- This is equivalent to the standard ANSI SQL literal: /// SELECT DATE '2025-07-16' /// /// [ODBC syntax]: https://learn.microsoft.com/en-us/sql/odbc/reference/develop-app/date-time-and-timestamp-literals?view=sql-server-2017 pub uses_odbc_syntax: bool, } impl fmt::Display for TypedString { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let data_type = &self.data_type; let value = &self.value; match self.uses_odbc_syntax { false => { write!(f, "{data_type}")?; write!(f, " {value}") } true => { let prefix = match data_type { DataType::Date => "d", DataType::Time(..) => "t", DataType::Timestamp(..) => "ts", _ => "?", }; write!(f, "{{{prefix} {value}}}") } } } } /// A function call #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct Function { /// The function name (may be qualified). pub name: ObjectName, /// Flags whether this function call uses the [ODBC syntax]. /// /// Example: /// ```sql /// SELECT {fn CONCAT('foo', 'bar')} /// ``` /// /// [ODBC syntax]: https://learn.microsoft.com/en-us/sql/odbc/reference/develop-app/scalar-function-calls?view=sql-server-2017 pub uses_odbc_syntax: bool, /// The parameters to the function, including any options specified within the /// delimiting parentheses. /// /// Example: /// ```plaintext /// HISTOGRAM(0.5, 0.6)(x, y) /// ``` /// /// [ClickHouse](https://clickhouse.com/docs/en/sql-reference/aggregate-functions/parametric-functions) pub parameters: FunctionArguments, /// The arguments to the function, including any options specified within the /// delimiting parentheses. pub args: FunctionArguments, /// e.g. `x > 5` in `COUNT(x) FILTER (WHERE x > 5)` pub filter: Option>, /// Indicates how `NULL`s should be handled in the calculation. /// /// Example: /// ```plaintext /// FIRST_VALUE( ) [ { IGNORE | RESPECT } NULLS ] OVER ... /// ``` /// /// [Snowflake](https://docs.snowflake.com/en/sql-reference/functions/first_value) pub null_treatment: Option, /// The `OVER` clause, indicating a window function call. pub over: Option, /// A clause used with certain aggregate functions to control the ordering /// within grouped sets before the function is applied. /// /// Syntax: /// ```plaintext /// (expression) WITHIN GROUP (ORDER BY key [ASC | DESC], ...) /// ``` pub within_group: Vec, } impl fmt::Display for Function { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { if self.uses_odbc_syntax { write!(f, "{{fn ")?; } write!(f, "{}{}{}", self.name, self.parameters, self.args)?; if !self.within_group.is_empty() { write!( f, " WITHIN GROUP (ORDER BY {})", display_comma_separated(&self.within_group) )?; } if let Some(filter_cond) = &self.filter { write!(f, " FILTER (WHERE {filter_cond})")?; } if let Some(null_treatment) = &self.null_treatment { write!(f, " {null_treatment}")?; } if let Some(o) = &self.over { f.write_str(" OVER ")?; o.fmt(f)?; } if self.uses_odbc_syntax { write!(f, "}}")?; } Ok(()) } } /// The arguments passed to a function call. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum FunctionArguments { /// Used for special functions like `CURRENT_TIMESTAMP` that are invoked /// without parentheses. None, /// On some dialects, a subquery can be passed without surrounding /// parentheses if it's the sole argument to the function. Subquery(Box), /// A normal function argument list, including any clauses within it such as /// `DISTINCT` or `ORDER BY`. List(FunctionArgumentList), } impl fmt::Display for FunctionArguments { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { FunctionArguments::None => Ok(()), FunctionArguments::Subquery(query) => write!(f, "({query})"), FunctionArguments::List(args) => write!(f, "({args})"), } } } /// This represents everything inside the parentheses when calling a function. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct FunctionArgumentList { /// `[ ALL | DISTINCT ]` pub duplicate_treatment: Option, /// The function arguments. pub args: Vec, /// Additional clauses specified within the argument list. pub clauses: Vec, } impl fmt::Display for FunctionArgumentList { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { if let Some(duplicate_treatment) = self.duplicate_treatment { write!(f, "{duplicate_treatment} ")?; } write!(f, "{}", display_comma_separated(&self.args))?; if !self.clauses.is_empty() { if !self.args.is_empty() { write!(f, " ")?; } write!(f, "{}", display_separated(&self.clauses, " "))?; } Ok(()) } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Clauses that can appear inside a function argument list. pub enum FunctionArgumentClause { /// Indicates how `NULL`s should be handled in the calculation, e.g. in `FIRST_VALUE` on [BigQuery]. /// /// Syntax: /// ```plaintext /// { IGNORE | RESPECT } NULLS ] /// ``` /// /// [BigQuery]: https://cloud.google.com/bigquery/docs/reference/standard-sql/navigation_functions#first_value IgnoreOrRespectNulls(NullTreatment), /// Specifies the the ordering for some ordered set aggregates, e.g. `ARRAY_AGG` on [BigQuery]. /// /// [BigQuery]: https://cloud.google.com/bigquery/docs/reference/standard-sql/aggregate_functions#array_agg OrderBy(Vec), /// Specifies a limit for the `ARRAY_AGG` and `ARRAY_CONCAT_AGG` functions on BigQuery. Limit(Expr), /// Specifies the behavior on overflow of the `LISTAGG` function. /// /// See . OnOverflow(ListAggOnOverflow), /// Specifies a minimum or maximum bound on the input to [`ANY_VALUE`] on BigQuery. /// /// Syntax: /// ```plaintext /// HAVING { MAX | MIN } expression /// ``` /// /// [`ANY_VALUE`]: https://cloud.google.com/bigquery/docs/reference/standard-sql/aggregate_functions#any_value Having(HavingBound), /// The `SEPARATOR` clause to the [`GROUP_CONCAT`] function in MySQL. /// /// [`GROUP_CONCAT`]: https://dev.mysql.com/doc/refman/8.0/en/aggregate-functions.html#function_group-concat Separator(ValueWithSpan), /// The `ON NULL` clause for some JSON functions. /// /// [MSSQL `JSON_ARRAY`](https://learn.microsoft.com/en-us/sql/t-sql/functions/json-array-transact-sql?view=sql-server-ver16) /// [MSSQL `JSON_OBJECT`](https://learn.microsoft.com/en-us/sql/t-sql/functions/json-object-transact-sql?view=sql-server-ver16>) /// [PostgreSQL JSON functions](https://www.postgresql.org/docs/current/functions-json.html#FUNCTIONS-JSON-PROCESSING) JsonNullClause(JsonNullClause), /// The `RETURNING` clause for some JSON functions in PostgreSQL /// /// [`JSON_OBJECT`](https://www.postgresql.org/docs/current/functions-json.html#:~:text=json_object) JsonReturningClause(JsonReturningClause), } impl fmt::Display for FunctionArgumentClause { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { FunctionArgumentClause::IgnoreOrRespectNulls(null_treatment) => { write!(f, "{null_treatment}") } FunctionArgumentClause::OrderBy(order_by) => { write!(f, "ORDER BY {}", display_comma_separated(order_by)) } FunctionArgumentClause::Limit(limit) => write!(f, "LIMIT {limit}"), FunctionArgumentClause::OnOverflow(on_overflow) => write!(f, "{on_overflow}"), FunctionArgumentClause::Having(bound) => write!(f, "{bound}"), FunctionArgumentClause::Separator(sep) => write!(f, "SEPARATOR {sep}"), FunctionArgumentClause::JsonNullClause(null_clause) => write!(f, "{null_clause}"), FunctionArgumentClause::JsonReturningClause(returning_clause) => { write!(f, "{returning_clause}") } } } } /// A method call #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct Method { /// The expression on which the method is invoked. pub expr: Box, // always non-empty /// The sequence of chained method calls. pub method_chain: Vec, } impl fmt::Display for Method { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "{}.{}", self.expr, display_separated(&self.method_chain, ".") ) } } #[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// How duplicate values are treated inside function argument lists. pub enum DuplicateTreatment { /// Consider only unique values. Distinct, /// Retain all duplicate values (the default). All, } impl fmt::Display for DuplicateTreatment { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { DuplicateTreatment::Distinct => write!(f, "DISTINCT"), DuplicateTreatment::All => write!(f, "ALL"), } } } #[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// How the `ANALYZE`/`EXPLAIN ANALYZE` format is specified. pub enum AnalyzeFormatKind { /// Format provided as a keyword, e.g. `FORMAT JSON`. Keyword(AnalyzeFormat), /// Format provided as an assignment, e.g. `FORMAT=JSON`. Assignment(AnalyzeFormat), } impl fmt::Display for AnalyzeFormatKind { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { match self { AnalyzeFormatKind::Keyword(format) => write!(f, "FORMAT {format}"), AnalyzeFormatKind::Assignment(format) => write!(f, "FORMAT={format}"), } } } #[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Output formats supported for `ANALYZE`/`EXPLAIN ANALYZE`. pub enum AnalyzeFormat { /// Plain text format. TEXT, /// Graphviz DOT format. GRAPHVIZ, /// JSON format. JSON, /// Traditional explain output. TRADITIONAL, /// Tree-style explain output. TREE, } impl fmt::Display for AnalyzeFormat { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { f.write_str(match self { AnalyzeFormat::TEXT => "TEXT", AnalyzeFormat::GRAPHVIZ => "GRAPHVIZ", AnalyzeFormat::JSON => "JSON", AnalyzeFormat::TRADITIONAL => "TRADITIONAL", AnalyzeFormat::TREE => "TREE", }) } } /// External table's available file format #[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 FileFormat { /// Text file format. TEXTFILE, /// Sequence file format. SEQUENCEFILE, /// ORC file format. ORC, /// Parquet file format. PARQUET, /// Avro file format. AVRO, /// RCFile format. RCFILE, /// JSON file format. JSONFILE, } impl fmt::Display for FileFormat { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { use self::FileFormat::*; f.write_str(match self { TEXTFILE => "TEXTFILE", SEQUENCEFILE => "SEQUENCEFILE", ORC => "ORC", PARQUET => "PARQUET", AVRO => "AVRO", RCFILE => "RCFILE", JSONFILE => "JSONFILE", }) } } /// The `ON OVERFLOW` clause of a LISTAGG invocation #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum ListAggOnOverflow { /// `ON OVERFLOW ERROR` Error, /// `ON OVERFLOW TRUNCATE [ ] WITH[OUT] COUNT` Truncate { /// Optional filler expression used when truncating. filler: Option>, /// Whether to include a count when truncating. with_count: bool, }, } impl fmt::Display for ListAggOnOverflow { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "ON OVERFLOW")?; match self { ListAggOnOverflow::Error => write!(f, " ERROR"), ListAggOnOverflow::Truncate { filler, with_count } => { write!(f, " TRUNCATE")?; if let Some(filler) = filler { write!(f, " {filler}")?; } if *with_count { write!(f, " WITH")?; } else { write!(f, " WITHOUT")?; } write!(f, " COUNT") } } } } /// The `HAVING` clause in a call to `ANY_VALUE` on BigQuery. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct HavingBound(pub HavingBoundKind, pub Expr); impl fmt::Display for HavingBound { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "HAVING {} {}", self.0, self.1) } } #[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Which bound is used in a HAVING clause for ANY_VALUE on BigQuery. pub enum HavingBoundKind { /// The minimum bound. Min, /// The maximum bound. Max, } impl fmt::Display for HavingBoundKind { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { HavingBoundKind::Min => write!(f, "MIN"), HavingBoundKind::Max => write!(f, "MAX"), } } } #[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Types of database objects referenced by DDL statements. pub enum ObjectType { /// A collation. Collation, /// A table. Table, /// A view. View, /// A materialized view. MaterializedView, /// An index. Index, /// A schema. Schema, /// A database. Database, /// A role. Role, /// A sequence. Sequence, /// A stage. Stage, /// A type definition. Type, /// A user. User, /// A stream. Stream, } impl fmt::Display for ObjectType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str(match self { ObjectType::Collation => "COLLATION", ObjectType::Table => "TABLE", ObjectType::View => "VIEW", ObjectType::MaterializedView => "MATERIALIZED VIEW", ObjectType::Index => "INDEX", ObjectType::Schema => "SCHEMA", ObjectType::Database => "DATABASE", ObjectType::Role => "ROLE", ObjectType::Sequence => "SEQUENCE", ObjectType::Stage => "STAGE", ObjectType::Type => "TYPE", ObjectType::User => "USER", ObjectType::Stream => "STREAM", }) } } #[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Types supported by `KILL` statements. pub enum KillType { /// Kill a connection. Connection, /// Kill a running query. Query, /// Kill a mutation (ClickHouse). Mutation, } impl fmt::Display for KillType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str(match self { // MySQL KillType::Connection => "CONNECTION", KillType::Query => "QUERY", // Clickhouse supports Mutation KillType::Mutation => "MUTATION", }) } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Distribution style options for Hive tables. pub enum HiveDistributionStyle { /// Partitioned distribution with the given columns. PARTITIONED { /// Columns used for partitioning. columns: Vec, }, /// Skewed distribution definition. SKEWED { /// Columns participating in the skew definition. columns: Vec, /// Columns listed in the `ON` clause for skewing. on: Vec, /// Whether skewed data is stored as directories. stored_as_directories: bool, }, /// No distribution style specified. NONE, } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Row format specification for Hive tables (SERDE or DELIMITED). pub enum HiveRowFormat { /// SerDe class specification with the implementing class name. SERDE { /// The SerDe implementation class name. class: String, }, /// Delimited row format with one or more delimiter specifications. DELIMITED { /// The list of delimiters used for delimiting fields/lines. delimiters: Vec, }, } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Format specification for `LOAD DATA` Hive operations. pub struct HiveLoadDataFormat { /// SerDe expression used for the table. pub serde: Expr, /// Input format expression. pub input_format: Expr, } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// A single row delimiter specification for Hive `ROW FORMAT`. pub struct HiveRowDelimiter { /// The delimiter kind (fields/lines/etc.). pub delimiter: HiveDelimiter, /// The delimiter character identifier. pub char: Ident, } impl fmt::Display for HiveRowDelimiter { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "{} ", self.delimiter)?; write!(f, "{}", self.char) } } #[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Kind of delimiter used in Hive `ROW FORMAT` definitions. pub enum HiveDelimiter { /// Fields terminated by a delimiter. FieldsTerminatedBy, /// Fields escaped by a character. FieldsEscapedBy, /// Collection items terminated by a delimiter. CollectionItemsTerminatedBy, /// Map keys terminated by a delimiter. MapKeysTerminatedBy, /// Lines terminated by a delimiter. LinesTerminatedBy, /// Null represented by a specific token. NullDefinedAs, } impl fmt::Display for HiveDelimiter { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { use HiveDelimiter::*; f.write_str(match self { FieldsTerminatedBy => "FIELDS TERMINATED BY", FieldsEscapedBy => "ESCAPED BY", CollectionItemsTerminatedBy => "COLLECTION ITEMS TERMINATED BY", MapKeysTerminatedBy => "MAP KEYS TERMINATED BY", LinesTerminatedBy => "LINES TERMINATED BY", NullDefinedAs => "NULL DEFINED AS", }) } } #[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Describe output format options for Hive `DESCRIBE`/`EXPLAIN`. pub enum HiveDescribeFormat { /// Extended describe output. Extended, /// Formatted describe output. Formatted, } impl fmt::Display for HiveDescribeFormat { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { use HiveDescribeFormat::*; f.write_str(match self { Extended => "EXTENDED", Formatted => "FORMATTED", }) } } #[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Aliases accepted for describe-style commands. pub enum DescribeAlias { /// `DESCRIBE` alias. Describe, /// `EXPLAIN` alias. Explain, /// `DESC` alias. Desc, } impl fmt::Display for DescribeAlias { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { use DescribeAlias::*; f.write_str(match self { Describe => "DESCRIBE", Explain => "EXPLAIN", Desc => "DESC", }) } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] #[allow(clippy::large_enum_variant)] /// Hive input/output format specification used in `CREATE TABLE`. pub enum HiveIOFormat { /// Generic IO format with separate input and output expressions. IOF { /// Expression for the input format. input_format: Expr, /// Expression for the output format. output_format: Expr, }, /// File format wrapper referencing a `FileFormat` variant. FileFormat { /// The file format used for storage. format: FileFormat, }, /// `USING ` syntax used by Spark SQL. /// /// Example: `CREATE TABLE t (i INT) USING PARQUET` /// /// See Using { /// The data source or format name, e.g. `parquet`, `delta`, `csv`. format: Ident, }, } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash, Default)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Hive table format and storage-related options. pub struct HiveFormat { /// Optional row format specification. pub row_format: Option, /// Optional SerDe properties expressed as SQL options. pub serde_properties: Option>, /// Optional input/output storage format details. pub storage: Option, /// Optional location (URI or path) for table data. pub location: Option, } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// A clustered index column specification. pub struct ClusteredIndex { /// Column identifier for the clustered index entry. pub name: Ident, /// Optional sort direction: `Some(true)` for ASC, `Some(false)` for DESC, `None` for unspecified. pub asc: Option, } impl fmt::Display for ClusteredIndex { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{}", self.name)?; match self.asc { Some(true) => write!(f, " ASC"), Some(false) => write!(f, " DESC"), _ => Ok(()), } } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Clustered options used for `CREATE TABLE` clustered/indexed storage. pub enum TableOptionsClustered { /// Use a columnstore index. ColumnstoreIndex, /// Columnstore index with an explicit ordering of columns. ColumnstoreIndexOrder(Vec), /// A named clustered index with one or more columns. Index(Vec), } impl fmt::Display for TableOptionsClustered { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { TableOptionsClustered::ColumnstoreIndex => { write!(f, "CLUSTERED COLUMNSTORE INDEX") } TableOptionsClustered::ColumnstoreIndexOrder(values) => { write!( f, "CLUSTERED COLUMNSTORE INDEX ORDER ({})", display_comma_separated(values) ) } TableOptionsClustered::Index(values) => { write!(f, "CLUSTERED INDEX ({})", display_comma_separated(values)) } } } } /// Specifies which partition the boundary values on table partitioning belongs to. #[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum PartitionRangeDirection { /// LEFT range direction. Left, /// RIGHT range direction. Right, } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// SQL option syntax used in table and server definitions. pub enum SqlOption { /// Clustered represents the clustered version of table storage for MSSQL. /// /// Clustered(TableOptionsClustered), /// Single identifier options, e.g. `HEAP` for MSSQL. /// /// Ident(Ident), /// Any option that consists of a key value pair where the value is an expression. e.g. /// /// WITH(DISTRIBUTION = ROUND_ROBIN) KeyValue { /// The option key identifier. key: Ident, /// The expression value for the option. value: Expr, }, /// One or more table partitions and represents which partition the boundary values belong to, /// e.g. /// /// PARTITION (id RANGE LEFT FOR VALUES (10, 20, 30, 40)) /// /// Partition { /// The partition column name. column_name: Ident, /// Optional direction for the partition range (LEFT/RIGHT). range_direction: Option, /// Values that define the partition boundaries. for_values: Vec, }, /// Comment parameter (supports `=` and no `=` syntax) Comment(CommentDef), /// MySQL TableSpace option /// TableSpace(TablespaceOption), /// An option representing a key value pair, where the value is a parenthesized list and with an optional name /// e.g. /// /// UNION = (tbl_name\[,tbl_name\]...) /// ENGINE = ReplicatedMergeTree('/table_name','{replica}', ver) /// ENGINE = SummingMergeTree(\[columns\]) NamedParenthesizedList(NamedParenthesizedList), } impl fmt::Display for SqlOption { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { SqlOption::Clustered(c) => write!(f, "{c}"), SqlOption::Ident(ident) => { write!(f, "{ident}") } SqlOption::KeyValue { key: name, value } => { write!(f, "{name} = {value}") } SqlOption::Partition { column_name, range_direction, for_values, } => { let direction = match range_direction { Some(PartitionRangeDirection::Left) => " LEFT", Some(PartitionRangeDirection::Right) => " RIGHT", None => "", }; write!( f, "PARTITION ({} RANGE{} FOR VALUES ({}))", column_name, direction, display_comma_separated(for_values) ) } SqlOption::TableSpace(tablespace_option) => { write!(f, "TABLESPACE {}", tablespace_option.name)?; match tablespace_option.storage { Some(StorageType::Disk) => write!(f, " STORAGE DISK"), Some(StorageType::Memory) => write!(f, " STORAGE MEMORY"), None => Ok(()), } } SqlOption::Comment(comment) => match comment { CommentDef::WithEq(comment) => { write!(f, "COMMENT = '{comment}'") } CommentDef::WithoutEq(comment) => { write!(f, "COMMENT '{comment}'") } }, SqlOption::NamedParenthesizedList(value) => { write!(f, "{} = ", value.key)?; if let Some(key) = &value.name { write!(f, "{key}")?; } if !value.values.is_empty() { write!(f, "({})", display_comma_separated(&value.values))? } Ok(()) } } } } #[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Storage type options for a tablespace. pub enum StorageType { /// Store on disk. Disk, /// Store in memory. Memory, } #[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// MySql TableSpace option /// pub struct TablespaceOption { /// Name of the tablespace. pub name: String, /// Optional storage type for the tablespace. pub storage: Option, } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// A key/value identifier pair used for secret or key-based options. pub struct SecretOption { /// The option key identifier. pub key: Ident, /// The option value identifier. pub value: Ident, } impl fmt::Display for SecretOption { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{} {}", self.key, self.value) } } /// A `CREATE SERVER` statement. /// /// [PostgreSQL Documentation](https://www.postgresql.org/docs/current/sql-createserver.html) #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct CreateServerStatement { /// The server name. pub name: ObjectName, /// Whether `IF NOT EXISTS` was specified. pub if_not_exists: bool, /// Optional server type identifier. pub server_type: Option, /// Optional server version identifier. pub version: Option, /// Foreign-data wrapper object name. pub foreign_data_wrapper: ObjectName, /// Optional list of server options. pub options: Option>, } impl fmt::Display for CreateServerStatement { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { let CreateServerStatement { name, if_not_exists, server_type, version, foreign_data_wrapper, options, } = self; write!( f, "CREATE SERVER {if_not_exists}{name} ", if_not_exists = if *if_not_exists { "IF NOT EXISTS " } else { "" }, )?; if let Some(st) = server_type { write!(f, "TYPE {st} ")?; } if let Some(v) = version { write!(f, "VERSION {v} ")?; } write!(f, "FOREIGN DATA WRAPPER {foreign_data_wrapper}")?; if let Some(o) = options { write!(f, " OPTIONS ({o})", o = display_comma_separated(o))?; } Ok(()) } } /// A key/value option for `CREATE SERVER`. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct CreateServerOption { /// Option key identifier. pub key: Ident, /// Option value identifier. pub value: Ident, } impl fmt::Display for CreateServerOption { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{} {}", self.key, self.value) } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Options supported by DuckDB for `ATTACH DATABASE`. pub enum AttachDuckDBDatabaseOption { /// READ_ONLY option, optional boolean value. ReadOnly(Option), /// TYPE option specifying a database type identifier. Type(Ident), } impl fmt::Display for AttachDuckDBDatabaseOption { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { AttachDuckDBDatabaseOption::ReadOnly(Some(true)) => write!(f, "READ_ONLY true"), AttachDuckDBDatabaseOption::ReadOnly(Some(false)) => write!(f, "READ_ONLY false"), AttachDuckDBDatabaseOption::ReadOnly(None) => write!(f, "READ_ONLY"), AttachDuckDBDatabaseOption::Type(t) => write!(f, "TYPE {t}"), } } } #[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Mode for transactions: access mode or isolation level. pub enum TransactionMode { /// Access mode for a transaction (e.g. `READ ONLY` / `READ WRITE`). AccessMode(TransactionAccessMode), /// Isolation level for a transaction (e.g. `SERIALIZABLE`). IsolationLevel(TransactionIsolationLevel), } impl fmt::Display for TransactionMode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { use TransactionMode::*; match self { AccessMode(access_mode) => write!(f, "{access_mode}"), IsolationLevel(iso_level) => write!(f, "ISOLATION LEVEL {iso_level}"), } } } #[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Transaction access mode (READ ONLY / READ WRITE). pub enum TransactionAccessMode { /// READ ONLY access mode. ReadOnly, /// READ WRITE access mode. ReadWrite, } impl fmt::Display for TransactionAccessMode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { use TransactionAccessMode::*; f.write_str(match self { ReadOnly => "READ ONLY", ReadWrite => "READ WRITE", }) } } #[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Transaction isolation levels. pub enum TransactionIsolationLevel { /// READ UNCOMMITTED isolation level. ReadUncommitted, /// READ COMMITTED isolation level. ReadCommitted, /// REPEATABLE READ isolation level. RepeatableRead, /// SERIALIZABLE isolation level. Serializable, /// SNAPSHOT isolation level. Snapshot, } impl fmt::Display for TransactionIsolationLevel { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { use TransactionIsolationLevel::*; f.write_str(match self { ReadUncommitted => "READ UNCOMMITTED", ReadCommitted => "READ COMMITTED", RepeatableRead => "REPEATABLE READ", Serializable => "SERIALIZABLE", Snapshot => "SNAPSHOT", }) } } /// Modifier for the transaction in the `BEGIN` syntax /// /// SQLite: /// MS-SQL: #[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 TransactionModifier { /// DEFERRED transaction modifier. Deferred, /// IMMEDIATE transaction modifier. Immediate, /// EXCLUSIVE transaction modifier. Exclusive, /// TRY block modifier (MS-SQL style TRY/CATCH). Try, /// CATCH block modifier (MS-SQL style TRY/CATCH). Catch, } impl fmt::Display for TransactionModifier { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { use TransactionModifier::*; f.write_str(match self { Deferred => "DEFERRED", Immediate => "IMMEDIATE", Exclusive => "EXCLUSIVE", Try => "TRY", Catch => "CATCH", }) } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Filter forms usable in SHOW statements. pub enum ShowStatementFilter { /// Filter using LIKE pattern. Like(String), /// Filter using ILIKE pattern. ILike(String), /// Filter using a WHERE expression. Where(Expr), /// Filter provided without a keyword (raw string). NoKeyword(String), } impl fmt::Display for ShowStatementFilter { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { use ShowStatementFilter::*; match self { Like(pattern) => write!(f, "LIKE '{}'", value::escape_single_quote_string(pattern)), ILike(pattern) => write!(f, "ILIKE {}", value::escape_single_quote_string(pattern)), Where(expr) => write!(f, "WHERE {expr}"), NoKeyword(pattern) => write!(f, "'{}'", value::escape_single_quote_string(pattern)), } } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Clause types used with SHOW ... IN/FROM. pub enum ShowStatementInClause { /// Use the `IN` clause. IN, /// Use the `FROM` clause. FROM, } impl fmt::Display for ShowStatementInClause { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { use ShowStatementInClause::*; match self { FROM => write!(f, "FROM"), IN => write!(f, "IN"), } } } /// Sqlite specific syntax /// /// See [Sqlite documentation](https://sqlite.org/lang_conflict.html) /// for more details. #[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 SqliteOnConflict { /// Use ROLLBACK on conflict. Rollback, /// Use ABORT on conflict. Abort, /// Use FAIL on conflict. Fail, /// Use IGNORE on conflict. Ignore, /// Use REPLACE on conflict. Replace, } impl fmt::Display for SqliteOnConflict { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { use SqliteOnConflict::*; match self { Rollback => write!(f, "OR ROLLBACK"), Abort => write!(f, "OR ABORT"), Fail => write!(f, "OR FAIL"), Ignore => write!(f, "OR IGNORE"), Replace => write!(f, "OR REPLACE"), } } } /// Mysql specific syntax /// /// See [Mysql documentation](https://dev.mysql.com/doc/refman/8.0/en/replace.html) /// See [Mysql documentation](https://dev.mysql.com/doc/refman/8.0/en/insert.html) /// for more details. #[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 MysqlInsertPriority { /// LOW_PRIORITY modifier for INSERT/REPLACE. LowPriority, /// DELAYED modifier for INSERT/REPLACE. Delayed, /// HIGH_PRIORITY modifier for INSERT/REPLACE. HighPriority, } impl fmt::Display for crate::ast::MysqlInsertPriority { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { use MysqlInsertPriority::*; match self { LowPriority => write!(f, "LOW_PRIORITY"), Delayed => write!(f, "DELAYED"), HighPriority => write!(f, "HIGH_PRIORITY"), } } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Source for the `COPY` command: a table or a query. pub enum CopySource { /// Copy from a table with optional column list. Table { /// The name of the table to copy from. table_name: ObjectName, /// A list of column names to copy. Empty list means that all columns /// are copied. columns: Vec, }, /// Copy from the results of a query. Query(Box), } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Target for the `COPY` command: STDIN, STDOUT, a file, or a program. pub enum CopyTarget { /// Use standard input as the source. Stdin, /// Use standard output as the target. Stdout, /// Read from or write to a file. File { /// The path name of the input or output file. filename: String, }, /// Use a program as the source or target (shell command). Program { /// A command to execute command: String, }, } impl fmt::Display for CopyTarget { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { use CopyTarget::*; match self { Stdin => write!(f, "STDIN"), Stdout => write!(f, "STDOUT"), File { filename } => write!(f, "'{}'", value::escape_single_quote_string(filename)), Program { command } => write!( f, "PROGRAM '{}'", value::escape_single_quote_string(command) ), } } } #[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Action to take `ON COMMIT` for temporary tables. pub enum OnCommit { /// Delete rows on commit. DeleteRows, /// Preserve rows on commit. PreserveRows, /// Drop the table on commit. Drop, } /// An option in `COPY` statement. /// /// #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum CopyOption { /// FORMAT format_name Format(Ident), /// FREEZE \[ boolean \] Freeze(bool), /// DELIMITER 'delimiter_character' Delimiter(char), /// NULL 'null_string' Null(String), /// HEADER \[ boolean \] Header(bool), /// QUOTE 'quote_character' Quote(char), /// ESCAPE 'escape_character' Escape(char), /// FORCE_QUOTE { ( column_name [, ...] ) | * } ForceQuote(Vec), /// FORCE_NOT_NULL ( column_name [, ...] ) ForceNotNull(Vec), /// FORCE_NULL ( column_name [, ...] ) ForceNull(Vec), /// ENCODING 'encoding_name' Encoding(String), } impl fmt::Display for CopyOption { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { use CopyOption::*; match self { Format(name) => write!(f, "FORMAT {name}"), Freeze(true) => write!(f, "FREEZE"), Freeze(false) => write!(f, "FREEZE FALSE"), Delimiter(char) => write!(f, "DELIMITER '{char}'"), Null(string) => write!(f, "NULL '{}'", value::escape_single_quote_string(string)), Header(true) => write!(f, "HEADER"), Header(false) => write!(f, "HEADER FALSE"), Quote(char) => write!(f, "QUOTE '{char}'"), Escape(char) => write!(f, "ESCAPE '{char}'"), ForceQuote(columns) => write!(f, "FORCE_QUOTE ({})", display_comma_separated(columns)), ForceNotNull(columns) => { write!(f, "FORCE_NOT_NULL ({})", display_comma_separated(columns)) } ForceNull(columns) => write!(f, "FORCE_NULL ({})", display_comma_separated(columns)), Encoding(name) => write!(f, "ENCODING '{}'", value::escape_single_quote_string(name)), } } } /// An option in `COPY` statement before PostgreSQL version 9.0. /// /// [PostgreSQL](https://www.postgresql.org/docs/8.4/sql-copy.html) /// [Redshift](https://docs.aws.amazon.com/redshift/latest/dg/r_COPY-alphabetical-parm-list.html) #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum CopyLegacyOption { /// ACCEPTANYDATE AcceptAnyDate, /// ACCEPTINVCHARS AcceptInvChars(Option), /// ADDQUOTES AddQuotes, /// ALLOWOVERWRITE AllowOverwrite, /// BINARY Binary, /// BLANKSASNULL BlankAsNull, /// BZIP2 Bzip2, /// CLEANPATH CleanPath, /// COMPUPDATE [ PRESET | { ON | TRUE } | { OFF | FALSE } ] CompUpdate { /// Whether the COMPUPDATE PRESET option was used. preset: bool, /// Optional enabled flag for COMPUPDATE. enabled: Option, }, /// CSV ... Csv(Vec), /// DATEFORMAT \[ AS \] {'dateformat_string' | 'auto' } DateFormat(Option), /// DELIMITER \[ AS \] 'delimiter_character' Delimiter(char), /// EMPTYASNULL EmptyAsNull, /// `ENCRYPTED \[ AUTO \]` Encrypted { /// Whether `AUTO` was specified for encryption. auto: bool, }, /// ESCAPE Escape, /// EXTENSION 'extension-name' Extension(String), /// FIXEDWIDTH \[ AS \] 'fixedwidth-spec' FixedWidth(String), /// GZIP Gzip, /// HEADER Header, /// IAM_ROLE { DEFAULT | 'arn:aws:iam::123456789:role/role1' } IamRole(IamRoleKind), /// IGNOREHEADER \[ AS \] number_rows IgnoreHeader(u64), /// JSON \[ AS \] 'json_option' Json(Option), /// MANIFEST \[ VERBOSE \] Manifest { /// Whether the MANIFEST is verbose. verbose: bool, }, /// MAXFILESIZE \[ AS \] max-size \[ MB | GB \] MaxFileSize(FileSize), /// `NULL \[ AS \] 'null_string'` Null(String), /// `PARALLEL [ { ON | TRUE } | { OFF | FALSE } ]` Parallel(Option), /// PARQUET Parquet, /// PARTITION BY ( column_name [, ... ] ) \[ INCLUDE \] PartitionBy(UnloadPartitionBy), /// REGION \[ AS \] 'aws-region' } Region(String), /// REMOVEQUOTES RemoveQuotes, /// ROWGROUPSIZE \[ AS \] size \[ MB | GB \] RowGroupSize(FileSize), /// STATUPDATE [ { ON | TRUE } | { OFF | FALSE } ] StatUpdate(Option), /// TIMEFORMAT \[ AS \] {'timeformat_string' | 'auto' | 'epochsecs' | 'epochmillisecs' } TimeFormat(Option), /// TRUNCATECOLUMNS TruncateColumns, /// ZSTD Zstd, /// Redshift `CREDENTIALS 'auth-args'` /// Credentials(String), } impl fmt::Display for CopyLegacyOption { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { use CopyLegacyOption::*; match self { AcceptAnyDate => write!(f, "ACCEPTANYDATE"), AcceptInvChars(ch) => { write!(f, "ACCEPTINVCHARS")?; if let Some(ch) = ch { write!(f, " '{}'", value::escape_single_quote_string(ch))?; } Ok(()) } AddQuotes => write!(f, "ADDQUOTES"), AllowOverwrite => write!(f, "ALLOWOVERWRITE"), Binary => write!(f, "BINARY"), BlankAsNull => write!(f, "BLANKSASNULL"), Bzip2 => write!(f, "BZIP2"), CleanPath => write!(f, "CLEANPATH"), CompUpdate { preset, enabled } => { write!(f, "COMPUPDATE")?; if *preset { write!(f, " PRESET")?; } else if let Some(enabled) = enabled { write!( f, "{}", match enabled { true => " TRUE", false => " FALSE", } )?; } Ok(()) } Csv(opts) => { write!(f, "CSV")?; if !opts.is_empty() { write!(f, " {}", display_separated(opts, " "))?; } Ok(()) } DateFormat(fmt) => { write!(f, "DATEFORMAT")?; if let Some(fmt) = fmt { write!(f, " '{}'", value::escape_single_quote_string(fmt))?; } Ok(()) } Delimiter(char) => write!(f, "DELIMITER '{char}'"), EmptyAsNull => write!(f, "EMPTYASNULL"), Encrypted { auto } => write!(f, "ENCRYPTED{}", if *auto { " AUTO" } else { "" }), Escape => write!(f, "ESCAPE"), Extension(ext) => write!(f, "EXTENSION '{}'", value::escape_single_quote_string(ext)), FixedWidth(spec) => write!( f, "FIXEDWIDTH '{}'", value::escape_single_quote_string(spec) ), Gzip => write!(f, "GZIP"), Header => write!(f, "HEADER"), IamRole(role) => write!(f, "IAM_ROLE {role}"), IgnoreHeader(num_rows) => write!(f, "IGNOREHEADER {num_rows}"), Json(opt) => { write!(f, "JSON")?; if let Some(opt) = opt { write!(f, " AS '{}'", value::escape_single_quote_string(opt))?; } Ok(()) } Manifest { verbose } => write!(f, "MANIFEST{}", if *verbose { " VERBOSE" } else { "" }), MaxFileSize(file_size) => write!(f, "MAXFILESIZE {file_size}"), Null(string) => write!(f, "NULL '{}'", value::escape_single_quote_string(string)), Parallel(enabled) => { write!( f, "PARALLEL{}", match enabled { Some(true) => " TRUE", Some(false) => " FALSE", _ => "", } ) } Parquet => write!(f, "PARQUET"), PartitionBy(p) => write!(f, "{p}"), Region(region) => write!(f, "REGION '{}'", value::escape_single_quote_string(region)), RemoveQuotes => write!(f, "REMOVEQUOTES"), RowGroupSize(file_size) => write!(f, "ROWGROUPSIZE {file_size}"), StatUpdate(enabled) => { write!( f, "STATUPDATE{}", match enabled { Some(true) => " TRUE", Some(false) => " FALSE", _ => "", } ) } TimeFormat(fmt) => { write!(f, "TIMEFORMAT")?; if let Some(fmt) = fmt { write!(f, " '{}'", value::escape_single_quote_string(fmt))?; } Ok(()) } TruncateColumns => write!(f, "TRUNCATECOLUMNS"), Zstd => write!(f, "ZSTD"), Credentials(s) => write!(f, "CREDENTIALS '{}'", value::escape_single_quote_string(s)), } } } /// ```sql /// SIZE \[ MB | GB \] /// ``` #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct FileSize { /// Numeric size value. pub size: ValueWithSpan, /// Optional unit for the size (MB or GB). pub unit: Option, } impl fmt::Display for FileSize { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{}", self.size)?; if let Some(unit) = &self.unit { write!(f, " {unit}")?; } Ok(()) } } /// Units for `FileSize` (MB or GB). #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum FileSizeUnit { /// Megabytes. MB, /// Gigabytes. GB, } impl fmt::Display for FileSizeUnit { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { FileSizeUnit::MB => write!(f, "MB"), FileSizeUnit::GB => write!(f, "GB"), } } } /// Specifies the partition keys for the unload operation /// /// ```sql /// PARTITION BY ( column_name [, ... ] ) [ INCLUDE ] /// ``` #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct UnloadPartitionBy { /// Columns used to partition the unload output. pub columns: Vec, /// Whether to include the partition in the output. pub include: bool, } impl fmt::Display for UnloadPartitionBy { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "PARTITION BY ({}){}", display_comma_separated(&self.columns), if self.include { " INCLUDE" } else { "" } ) } } /// An `IAM_ROLE` option in the AWS ecosystem /// /// [Redshift COPY](https://docs.aws.amazon.com/redshift/latest/dg/copy-parameters-authorization.html#copy-iam-role) #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum IamRoleKind { /// Default role Default, /// Specific role ARN, for example: `arn:aws:iam::123456789:role/role1` Arn(String), } impl fmt::Display for IamRoleKind { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { IamRoleKind::Default => write!(f, "DEFAULT"), IamRoleKind::Arn(arn) => write!(f, "'{arn}'"), } } } /// A `CSV` option in `COPY` statement before PostgreSQL version 9.0. /// /// #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum CopyLegacyCsvOption { /// HEADER Header, /// QUOTE \[ AS \] 'quote_character' Quote(char), /// ESCAPE \[ AS \] 'escape_character' Escape(char), /// FORCE QUOTE { column_name [, ...] | * } ForceQuote(Vec), /// FORCE NOT NULL column_name [, ...] ForceNotNull(Vec), } impl fmt::Display for CopyLegacyCsvOption { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { use CopyLegacyCsvOption::*; match self { Header => write!(f, "HEADER"), Quote(char) => write!(f, "QUOTE '{char}'"), Escape(char) => write!(f, "ESCAPE '{char}'"), ForceQuote(columns) => write!(f, "FORCE QUOTE {}", display_comma_separated(columns)), ForceNotNull(columns) => { write!(f, "FORCE NOT NULL {}", display_comma_separated(columns)) } } } } /// Objects that can be discarded with `DISCARD`. #[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 DiscardObject { /// Discard all session state. ALL, /// Discard cached plans. PLANS, /// Discard sequence values. SEQUENCES, /// Discard temporary objects. TEMP, } impl fmt::Display for DiscardObject { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { DiscardObject::ALL => f.write_str("ALL"), DiscardObject::PLANS => f.write_str("PLANS"), DiscardObject::SEQUENCES => f.write_str("SEQUENCES"), DiscardObject::TEMP => f.write_str("TEMP"), } } } /// Types of flush operations supported by `FLUSH`. #[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 FlushType { /// Flush binary logs. BinaryLogs, /// Flush engine logs. EngineLogs, /// Flush error logs. ErrorLogs, /// Flush general logs. GeneralLogs, /// Flush hosts information. Hosts, /// Flush logs. Logs, /// Flush privileges. Privileges, /// Flush optimizer costs. OptimizerCosts, /// Flush relay logs. RelayLogs, /// Flush slow logs. SlowLogs, /// Flush status. Status, /// Flush user resources. UserResources, /// Flush table data. Tables, } impl fmt::Display for FlushType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { FlushType::BinaryLogs => f.write_str("BINARY LOGS"), FlushType::EngineLogs => f.write_str("ENGINE LOGS"), FlushType::ErrorLogs => f.write_str("ERROR LOGS"), FlushType::GeneralLogs => f.write_str("GENERAL LOGS"), FlushType::Hosts => f.write_str("HOSTS"), FlushType::Logs => f.write_str("LOGS"), FlushType::Privileges => f.write_str("PRIVILEGES"), FlushType::OptimizerCosts => f.write_str("OPTIMIZER_COSTS"), FlushType::RelayLogs => f.write_str("RELAY LOGS"), FlushType::SlowLogs => f.write_str("SLOW LOGS"), FlushType::Status => f.write_str("STATUS"), FlushType::UserResources => f.write_str("USER_RESOURCES"), FlushType::Tables => f.write_str("TABLES"), } } } /// Location modifier for flush commands. #[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 FlushLocation { /// Do not write changes to the binary log. NoWriteToBinlog, /// Apply flush locally. Local, } impl fmt::Display for FlushLocation { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { FlushLocation::NoWriteToBinlog => f.write_str("NO_WRITE_TO_BINLOG"), FlushLocation::Local => f.write_str("LOCAL"), } } } /// Optional context modifier for statements that can be or `LOCAL`, `GLOBAL`, or `SESSION`. #[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 ContextModifier { /// `LOCAL` identifier, usually related to transactional states. Local, /// `SESSION` identifier Session, /// `GLOBAL` identifier Global, } impl fmt::Display for ContextModifier { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { Self::Local => { write!(f, "LOCAL ") } Self::Session => { write!(f, "SESSION ") } Self::Global => { write!(f, "GLOBAL ") } } } } /// Function describe in DROP FUNCTION. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] pub enum DropFunctionOption { /// `RESTRICT` option for DROP FUNCTION. Restrict, /// `CASCADE` option for DROP FUNCTION. Cascade, } impl fmt::Display for DropFunctionOption { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { DropFunctionOption::Restrict => write!(f, "RESTRICT "), DropFunctionOption::Cascade => write!(f, "CASCADE "), } } } /// Generic function description for DROP FUNCTION and CREATE TRIGGER. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct FunctionDesc { /// The function name. pub name: ObjectName, /// Optional list of function arguments. pub args: Option>, } impl fmt::Display for FunctionDesc { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{}", self.name)?; if let Some(args) = &self.args { write!(f, "({})", display_comma_separated(args))?; } Ok(()) } } /// Function argument in CREATE OR DROP FUNCTION. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct OperateFunctionArg { /// Optional argument mode (`IN`, `OUT`, `INOUT`). pub mode: Option, /// Optional argument identifier/name. pub name: Option, /// The data type of the argument. pub data_type: DataType, /// Optional default expression for the argument. pub default_expr: Option, } impl OperateFunctionArg { /// Returns an unnamed argument. pub fn unnamed(data_type: DataType) -> Self { Self { mode: None, name: None, data_type, default_expr: None, } } /// Returns an argument with name. pub fn with_name(name: &str, data_type: DataType) -> Self { Self { mode: None, name: Some(name.into()), data_type, default_expr: None, } } } impl fmt::Display for OperateFunctionArg { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { if let Some(mode) = &self.mode { write!(f, "{mode} ")?; } if let Some(name) = &self.name { write!(f, "{name} ")?; } write!(f, "{}", self.data_type)?; if let Some(default_expr) = &self.default_expr { write!(f, " = {default_expr}")?; } Ok(()) } } /// The mode of an argument in CREATE FUNCTION. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum ArgMode { /// `IN` mode. In, /// `OUT` mode. Out, /// `INOUT` mode. InOut, /// `VARIADIC` mode. Variadic, } impl fmt::Display for ArgMode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { ArgMode::In => write!(f, "IN"), ArgMode::Out => write!(f, "OUT"), ArgMode::InOut => write!(f, "INOUT"), ArgMode::Variadic => write!(f, "VARIADIC"), } } } /// These attributes inform the query optimizer about the behavior of the function. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum FunctionBehavior { /// Function is immutable. Immutable, /// Function is stable. Stable, /// Function is volatile. Volatile, } impl fmt::Display for FunctionBehavior { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { FunctionBehavior::Immutable => write!(f, "IMMUTABLE"), FunctionBehavior::Stable => write!(f, "STABLE"), FunctionBehavior::Volatile => write!(f, "VOLATILE"), } } } /// Security attribute for functions: SECURITY DEFINER or SECURITY INVOKER. /// /// [PostgreSQL](https://www.postgresql.org/docs/current/sql-createfunction.html) #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum FunctionSecurity { /// Execute the function with the privileges of the user who defined it. Definer, /// Execute the function with the privileges of the user who invokes it. Invoker, } impl fmt::Display for FunctionSecurity { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { FunctionSecurity::Definer => write!(f, "SECURITY DEFINER"), FunctionSecurity::Invoker => write!(f, "SECURITY INVOKER"), } } } /// Value for a SET configuration parameter in a CREATE FUNCTION statement. /// /// [PostgreSQL](https://www.postgresql.org/docs/current/sql-createfunction.html) #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum FunctionSetValue { /// SET param = DEFAULT / SET param TO DEFAULT Default, /// SET param = value1, value2, ... Values(Vec), /// SET param FROM CURRENT FromCurrent, } /// A SET configuration_parameter clause in a CREATE FUNCTION statement. /// /// [PostgreSQL](https://www.postgresql.org/docs/current/sql-createfunction.html) #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct FunctionDefinitionSetParam { /// The name of the configuration parameter. pub name: ObjectName, /// The value to set for the parameter. pub value: FunctionSetValue, } impl fmt::Display for FunctionDefinitionSetParam { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "SET {} ", self.name)?; match &self.value { FunctionSetValue::Default => write!(f, "= DEFAULT"), FunctionSetValue::Values(values) => { write!(f, "= {}", display_comma_separated(values)) } FunctionSetValue::FromCurrent => write!(f, "FROM CURRENT"), } } } /// These attributes describe the behavior of the function when called with a null argument. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum FunctionCalledOnNull { /// Function is called even when inputs are null. CalledOnNullInput, /// Function returns null when any input is null. ReturnsNullOnNullInput, /// Function is strict about null inputs. Strict, } impl fmt::Display for FunctionCalledOnNull { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { FunctionCalledOnNull::CalledOnNullInput => write!(f, "CALLED ON NULL INPUT"), FunctionCalledOnNull::ReturnsNullOnNullInput => write!(f, "RETURNS NULL ON NULL INPUT"), FunctionCalledOnNull::Strict => write!(f, "STRICT"), } } } /// If it is safe for PostgreSQL to call the function from multiple threads at once #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum FunctionParallel { /// The function is not safe to run in parallel. Unsafe, /// The function is restricted for parallel execution. Restricted, /// The function is safe to run in parallel. Safe, } impl fmt::Display for FunctionParallel { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { FunctionParallel::Unsafe => write!(f, "PARALLEL UNSAFE"), FunctionParallel::Restricted => write!(f, "PARALLEL RESTRICTED"), FunctionParallel::Safe => write!(f, "PARALLEL SAFE"), } } } /// [BigQuery] Determinism specifier used in a UDF definition. /// /// [BigQuery]: https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language#syntax_11 #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum FunctionDeterminismSpecifier { /// Function is deterministic. Deterministic, /// Function is not deterministic. NotDeterministic, } impl fmt::Display for FunctionDeterminismSpecifier { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { FunctionDeterminismSpecifier::Deterministic => { write!(f, "DETERMINISTIC") } FunctionDeterminismSpecifier::NotDeterministic => { write!(f, "NOT DETERMINISTIC") } } } } /// Represent the expression body of a `CREATE FUNCTION` statement as well as /// where within the statement, the body shows up. /// /// [BigQuery]: https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language#syntax_11 /// [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 #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum CreateFunctionBody { /// A function body expression using the 'AS' keyword and shows up /// before any `OPTIONS` clause. /// /// Example: /// ```sql /// CREATE FUNCTION myfunc(x FLOAT64, y FLOAT64) RETURNS FLOAT64 /// AS (x * y) /// OPTIONS(description="desc"); /// ``` /// /// [BigQuery]: https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language#syntax_11 /// [PostgreSQL]: https://www.postgresql.org/docs/current/sql-createfunction.html AsBeforeOptions { /// The primary expression. body: Expr, /// Link symbol if the primary expression contains the name of shared library file. /// /// Example: /// ```sql /// CREATE FUNCTION cas_in(input cstring) RETURNS cas /// AS 'MODULE_PATHNAME', 'cas_in_wrapper' /// ``` /// [PostgreSQL]: https://www.postgresql.org/docs/current/sql-createfunction.html link_symbol: Option, }, /// A function body expression using the 'AS' keyword and shows up /// after any `OPTIONS` clause. /// /// Example: /// ```sql /// CREATE FUNCTION myfunc(x FLOAT64, y FLOAT64) RETURNS FLOAT64 /// OPTIONS(description="desc") /// AS (x * y); /// ``` /// /// [BigQuery]: https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language#syntax_11 AsAfterOptions(Expr), /// Function body with statements before the `RETURN` keyword. /// /// Example: /// ```sql /// CREATE FUNCTION my_scalar_udf(a INT, b INT) /// RETURNS INT /// AS /// BEGIN /// DECLARE c INT; /// SET c = a + b; /// RETURN c; /// END /// ``` /// /// [MsSql]: https://learn.microsoft.com/en-us/sql/t-sql/statements/create-function-transact-sql AsBeginEnd(BeginEndStatements), /// Function body expression using the 'RETURN' keyword. /// /// Example: /// ```sql /// CREATE FUNCTION myfunc(a INTEGER, IN b INTEGER = 1) RETURNS INTEGER /// LANGUAGE SQL /// RETURN a + b; /// ``` /// /// [PostgreSQL]: https://www.postgresql.org/docs/current/sql-createfunction.html Return(Expr), /// Function body expression using the 'AS RETURN' keywords /// /// Example: /// ```sql /// CREATE FUNCTION myfunc(a INT, b INT) /// RETURNS TABLE /// AS RETURN (SELECT a + b AS sum); /// ``` /// /// [MsSql]: https://learn.microsoft.com/en-us/sql/t-sql/statements/create-function-transact-sql AsReturnExpr(Expr), /// Function body expression using the 'AS RETURN' keywords, with an un-parenthesized SELECT query /// /// Example: /// ```sql /// CREATE FUNCTION myfunc(a INT, b INT) /// RETURNS TABLE /// AS RETURN SELECT a + b AS sum; /// ``` /// /// [MsSql]: https://learn.microsoft.com/en-us/sql/t-sql/statements/create-function-transact-sql?view=sql-server-ver16#select_stmt AsReturnSelect(Select), } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// `USING` clause options for `CREATE FUNCTION` (e.g., JAR, FILE, ARCHIVE). pub enum CreateFunctionUsing { /// Use a JAR file located at the given URI. Jar(String), /// Use a file located at the given URI. File(String), /// Use an archive located at the given URI. Archive(String), } impl fmt::Display for CreateFunctionUsing { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "USING ")?; match self { CreateFunctionUsing::Jar(uri) => write!(f, "JAR '{uri}'"), CreateFunctionUsing::File(uri) => write!(f, "FILE '{uri}'"), CreateFunctionUsing::Archive(uri) => write!(f, "ARCHIVE '{uri}'"), } } } /// `NAME = ` arguments for DuckDB macros /// /// See [Create Macro - DuckDB](https://duckdb.org/docs/sql/statements/create_macro) /// for more details #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct MacroArg { /// The argument name. pub name: Ident, /// Optional default expression for the argument. pub default_expr: Option, } impl MacroArg { /// Returns an argument with name. pub fn new(name: &str) -> Self { Self { name: name.into(), default_expr: None, } } } impl fmt::Display for MacroArg { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{}", self.name)?; if let Some(default_expr) = &self.default_expr { write!(f, " := {default_expr}")?; } Ok(()) } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Definition for a DuckDB macro: either an expression or a table-producing query. pub enum MacroDefinition { /// The macro is defined as an expression. Expr(Expr), /// The macro is defined as a table (query). Table(Box), } impl fmt::Display for MacroDefinition { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { MacroDefinition::Expr(expr) => write!(f, "{expr}")?, MacroDefinition::Table(query) => write!(f, "{query}")?, } Ok(()) } } /// Schema possible naming variants ([1]). /// /// [1]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#schema-definition #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum SchemaName { /// Only schema name specified: ``. Simple(ObjectName), /// Only authorization identifier specified: `AUTHORIZATION `. UnnamedAuthorization(Ident), /// Both schema name and authorization identifier specified: ` AUTHORIZATION `. NamedAuthorization(ObjectName, Ident), } impl fmt::Display for SchemaName { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { SchemaName::Simple(name) => { write!(f, "{name}") } SchemaName::UnnamedAuthorization(authorization) => { write!(f, "AUTHORIZATION {authorization}") } SchemaName::NamedAuthorization(name, authorization) => { write!(f, "{name} AUTHORIZATION {authorization}") } } } } /// Fulltext search modifiers ([1]). /// /// [1]: https://dev.mysql.com/doc/refman/8.0/en/fulltext-search.html#function_match #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum SearchModifier { /// `IN NATURAL LANGUAGE MODE`. InNaturalLanguageMode, /// `IN NATURAL LANGUAGE MODE WITH QUERY EXPANSION`. InNaturalLanguageModeWithQueryExpansion, ///`IN BOOLEAN MODE`. InBooleanMode, ///`WITH QUERY EXPANSION`. WithQueryExpansion, } impl fmt::Display for SearchModifier { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { Self::InNaturalLanguageMode => { write!(f, "IN NATURAL LANGUAGE MODE")?; } Self::InNaturalLanguageModeWithQueryExpansion => { write!(f, "IN NATURAL LANGUAGE MODE WITH QUERY EXPANSION")?; } Self::InBooleanMode => { write!(f, "IN BOOLEAN MODE")?; } Self::WithQueryExpansion => { write!(f, "WITH QUERY EXPANSION")?; } } Ok(()) } } /// Represents a `LOCK TABLE` clause with optional alias and lock 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 LockTable { /// The table identifier to lock. pub table: Ident, /// Optional alias for the table. pub alias: Option, /// The type of lock to apply to the table. pub lock_type: LockTableType, } impl fmt::Display for LockTable { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { let Self { table: tbl_name, alias, lock_type, } = self; write!(f, "{tbl_name} ")?; if let Some(alias) = alias { write!(f, "AS {alias} ")?; } write!(f, "{lock_type}")?; Ok(()) } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// The type of lock used in `LOCK TABLE` statements. pub enum LockTableType { /// Shared/read lock. If `local` is true, it's a local read lock. Read { /// Whether the read lock is local. local: bool, }, /// Exclusive/write lock. If `low_priority` is true, the write is low priority. Write { /// Whether the write lock is low priority. low_priority: bool, }, } impl fmt::Display for LockTableType { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { Self::Read { local } => { write!(f, "READ")?; if *local { write!(f, " LOCAL")?; } } Self::Write { low_priority } => { if *low_priority { write!(f, "LOW_PRIORITY ")?; } write!(f, "WRITE")?; } } Ok(()) } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Hive-specific `SET LOCATION` helper used in some `LOAD DATA` statements. pub struct HiveSetLocation { /// Whether the `SET` keyword was present. pub has_set: bool, /// The location identifier. pub location: Ident, } impl fmt::Display for HiveSetLocation { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { if self.has_set { write!(f, "SET ")?; } write!(f, "LOCATION {}", self.location) } } /// MySQL `ALTER TABLE` only [FIRST | AFTER column_name] #[allow(clippy::large_enum_variant)] #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// MySQL `ALTER TABLE` column position specifier: `FIRST` or `AFTER `. pub enum MySQLColumnPosition { /// Place the column first in the table. First, /// Place the column after the specified identifier. After(Ident), } impl Display for MySQLColumnPosition { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { MySQLColumnPosition::First => write!(f, "FIRST"), MySQLColumnPosition::After(ident) => { let column_name = &ident.value; write!(f, "AFTER {column_name}") } } } } /// MySQL `CREATE VIEW` algorithm parameter: [ALGORITHM = {UNDEFINED | MERGE | TEMPTABLE}] #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// MySQL `CREATE VIEW` algorithm options. pub enum CreateViewAlgorithm { /// `UNDEFINED` algorithm. Undefined, /// `MERGE` algorithm. Merge, /// `TEMPTABLE` algorithm. TempTable, } impl Display for CreateViewAlgorithm { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { CreateViewAlgorithm::Undefined => write!(f, "UNDEFINED"), CreateViewAlgorithm::Merge => write!(f, "MERGE"), CreateViewAlgorithm::TempTable => write!(f, "TEMPTABLE"), } } } /// MySQL `CREATE VIEW` security parameter: [SQL SECURITY { DEFINER | INVOKER }] #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// MySQL `CREATE VIEW` SQL SECURITY options. pub enum CreateViewSecurity { /// The view runs with the privileges of the definer. Definer, /// The view runs with the privileges of the invoker. Invoker, } impl Display for CreateViewSecurity { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { CreateViewSecurity::Definer => write!(f, "DEFINER"), CreateViewSecurity::Invoker => write!(f, "INVOKER"), } } } /// [MySQL] `CREATE VIEW` additional parameters /// /// [MySQL]: https://dev.mysql.com/doc/refman/9.1/en/create-view.html #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct CreateViewParams { /// Optional view algorithm (e.g., MERGE, TEMPTABLE). pub algorithm: Option, /// Optional definer (the security principal that will own the view). pub definer: Option, /// Optional SQL SECURITY setting for the view. pub security: Option, } impl Display for CreateViewParams { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { let CreateViewParams { algorithm, definer, security, } = self; if let Some(algorithm) = algorithm { write!(f, "ALGORITHM = {algorithm} ")?; } if let Some(definers) = definer { write!(f, "DEFINER = {definers} ")?; } if let Some(security) = security { write!(f, "SQL SECURITY {security} ")?; } Ok(()) } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Key/Value, where the value is a (optionally named) list of identifiers /// /// ```sql /// UNION = (tbl_name[,tbl_name]...) /// ENGINE = ReplicatedMergeTree('/table_name','{replica}', ver) /// ENGINE = SummingMergeTree([columns]) /// ``` pub struct NamedParenthesizedList { /// The option key (identifier) for this named list. pub key: Ident, /// Optional secondary name associated with the key. pub name: Option, /// The list of identifier values for the key. pub values: Vec, } /// Snowflake `WITH ROW ACCESS POLICY policy_name ON (identifier, ...)` /// /// /// #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct RowAccessPolicy { /// The fully-qualified policy object name. pub policy: ObjectName, /// Identifiers for the columns or objects the policy applies to. pub on: Vec, } impl RowAccessPolicy { /// Create a new `RowAccessPolicy` for the given `policy` and `on` identifiers. pub fn new(policy: ObjectName, on: Vec) -> Self { Self { policy, on } } } impl Display for RowAccessPolicy { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "WITH ROW ACCESS POLICY {} ON ({})", self.policy, display_comma_separated(self.on.as_slice()) ) } } /// Snowflake `[ WITH ] STORAGE LIFECYCLE POLICY ON ( [ , ... ] )` /// /// #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct StorageLifecyclePolicy { /// The fully-qualified policy object name. pub policy: ObjectName, /// Column names the policy applies to. pub on: Vec, } impl Display for StorageLifecyclePolicy { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "WITH STORAGE LIFECYCLE POLICY {} ON ({})", self.policy, display_comma_separated(self.on.as_slice()) ) } } /// Snowflake `WITH TAG ( tag_name = '', ...)` /// /// #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct Tag { /// The tag key (can be qualified). pub key: ObjectName, /// The tag value as a string. pub value: String, } impl Tag { /// Create a new `Tag` with the given key and value. pub fn new(key: ObjectName, value: String) -> Self { Self { key, value } } } impl Display for Tag { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "{}='{}'", self.key, self.value) } } /// Snowflake `WITH CONTACT ( purpose = contact [ , purpose = contact ...] )` /// /// #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct ContactEntry { /// The purpose label for the contact entry. pub purpose: String, /// The contact information associated with the purpose. pub contact: String, } impl Display for ContactEntry { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "{} = {}", self.purpose, self.contact) } } /// Helper to indicate if a comment includes the `=` in the display form #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum CommentDef { /// Includes `=` when printing the comment, as `COMMENT = 'comment'` /// Does not include `=` when printing the comment, as `COMMENT 'comment'` WithEq(String), /// Comment variant that omits the `=` when displayed. WithoutEq(String), } impl Display for CommentDef { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { CommentDef::WithEq(comment) | CommentDef::WithoutEq(comment) => write!(f, "{comment}"), } } } /// Helper to indicate if a collection should be wrapped by a symbol in the display form /// /// [`Display`] is implemented for every [`Vec`] where `T: Display`. /// The string output is a comma separated list for the vec items /// /// # Examples /// ``` /// # use sqlparser::ast::WrappedCollection; /// let items = WrappedCollection::Parentheses(vec!["one", "two", "three"]); /// assert_eq!("(one, two, three)", items.to_string()); /// /// let items = WrappedCollection::NoWrapping(vec!["one", "two", "three"]); /// assert_eq!("one, two, three", items.to_string()); /// ``` #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum WrappedCollection { /// Print the collection without wrapping symbols, as `item, item, item` NoWrapping(T), /// Wraps the collection in Parentheses, as `(item, item, item)` Parentheses(T), } impl Display for WrappedCollection> where T: Display, { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { WrappedCollection::NoWrapping(inner) => { write!(f, "{}", display_comma_separated(inner.as_slice())) } WrappedCollection::Parentheses(inner) => { write!(f, "({})", display_comma_separated(inner.as_slice())) } } } } /// Represents a single PostgreSQL utility option. /// /// A utility option is a key-value pair where the key is an identifier (IDENT) and the value /// can be one of the following: /// - A number with an optional sign (`+` or `-`). Example: `+10`, `-10.2`, `3` /// - A non-keyword string. Example: `option1`, `'option2'`, `"option3"` /// - keyword: `TRUE`, `FALSE`, `ON` (`off` is also accept). /// - Empty. Example: `ANALYZE` (identifier only) /// /// Utility options are used in various PostgreSQL DDL statements, including statements such as /// `CLUSTER`, `EXPLAIN`, `VACUUM`, and `REINDEX`. These statements format options as `( option [, ...] )`. /// /// [CLUSTER](https://www.postgresql.org/docs/current/sql-cluster.html) /// [EXPLAIN](https://www.postgresql.org/docs/current/sql-explain.html) /// [VACUUM](https://www.postgresql.org/docs/current/sql-vacuum.html) /// [REINDEX](https://www.postgresql.org/docs/current/sql-reindex.html) /// /// For example, the `EXPLAIN` AND `VACUUM` statements with options might look like this: /// ```sql /// EXPLAIN (ANALYZE, VERBOSE TRUE, FORMAT TEXT) SELECT * FROM my_table; /// /// VACUUM (VERBOSE, ANALYZE ON, PARALLEL 10) my_table; /// ``` #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct UtilityOption { /// The option name (identifier). pub name: Ident, /// Optional argument for the option (number, string, keyword, etc.). pub arg: Option, } impl Display for UtilityOption { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { if let Some(ref arg) = self.arg { write!(f, "{} {}", self.name, arg) } else { write!(f, "{}", self.name) } } } /// Represents the different options available for `SHOW` /// statements to filter the results. Example from Snowflake: /// #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct ShowStatementOptions { /// Optional scope to show in (for example: TABLE, SCHEMA). pub show_in: Option, /// Optional `STARTS WITH` filter value. pub starts_with: Option, /// Optional `LIMIT` expression. pub limit: Option, /// Optional `FROM` value used with `LIMIT`. pub limit_from: Option, /// Optional filter position (infix or suffix) for `LIKE`/`FILTER`. pub filter_position: Option, } impl Display for ShowStatementOptions { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { let (like_in_infix, like_in_suffix) = match &self.filter_position { Some(ShowStatementFilterPosition::Infix(filter)) => { (format!(" {filter}"), "".to_string()) } Some(ShowStatementFilterPosition::Suffix(filter)) => { ("".to_string(), format!(" {filter}")) } None => ("".to_string(), "".to_string()), }; write!( f, "{like_in_infix}{show_in}{starts_with}{limit}{from}{like_in_suffix}", show_in = match &self.show_in { Some(i) => format!(" {i}"), None => String::new(), }, starts_with = match &self.starts_with { Some(s) => format!(" STARTS WITH {s}"), None => String::new(), }, limit = match &self.limit { Some(l) => format!(" LIMIT {l}"), None => String::new(), }, from = match &self.limit_from { Some(f) => format!(" FROM {f}"), None => String::new(), } )?; Ok(()) } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Where a `SHOW` filter appears relative to the main clause. pub enum ShowStatementFilterPosition { /// Put the filter in an infix position (e.g. `SHOW COLUMNS LIKE '%name%' IN TABLE tbl`). Infix(ShowStatementFilter), // For example: SHOW COLUMNS LIKE '%name%' IN TABLE tbl /// Put the filter in a suffix position (e.g. `SHOW COLUMNS IN tbl LIKE '%name%'`). Suffix(ShowStatementFilter), // For example: SHOW COLUMNS IN tbl LIKE '%name%' } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Parent object types usable with `SHOW ... IN ` clauses. pub enum ShowStatementInParentType { /// ACCOUNT parent type for SHOW statements. Account, /// DATABASE parent type for SHOW statements. Database, /// SCHEMA parent type for SHOW statements. Schema, /// TABLE parent type for SHOW statements. Table, /// VIEW parent type for SHOW statements. View, } impl fmt::Display for ShowStatementInParentType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { ShowStatementInParentType::Account => write!(f, "ACCOUNT"), ShowStatementInParentType::Database => write!(f, "DATABASE"), ShowStatementInParentType::Schema => write!(f, "SCHEMA"), ShowStatementInParentType::Table => write!(f, "TABLE"), ShowStatementInParentType::View => write!(f, "VIEW"), } } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Represents a `SHOW ... IN` clause with optional parent qualifier and name. pub struct ShowStatementIn { /// The clause that specifies what to show (e.g. COLUMNS, TABLES). pub clause: ShowStatementInClause, /// Optional parent type qualifier (ACCOUNT/DATABASE/...). pub parent_type: Option, /// Optional parent object name for the SHOW clause. #[cfg_attr(feature = "visitor", visit(with = "visit_relation"))] pub parent_name: Option, } impl fmt::Display for ShowStatementIn { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{}", self.clause)?; if let Some(parent_type) = &self.parent_type { write!(f, " {parent_type}")?; } if let Some(parent_name) = &self.parent_name { write!(f, " {parent_name}")?; } Ok(()) } } /// A Show Charset statement #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct ShowCharset { /// The statement can be written as `SHOW CHARSET` or `SHOW CHARACTER SET` /// true means CHARSET was used and false means CHARACTER SET was used pub is_shorthand: bool, /// Optional `LIKE`/`WHERE`-style filter for the statement. pub filter: Option, } impl fmt::Display for ShowCharset { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "SHOW")?; if self.is_shorthand { write!(f, " CHARSET")?; } else { write!(f, " CHARACTER SET")?; } if let Some(filter) = &self.filter { write!(f, " {filter}")?; } Ok(()) } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Options for a `SHOW OBJECTS` statement. pub struct ShowObjects { /// Whether to show terse output. pub terse: bool, /// Additional options controlling the SHOW output. pub show_options: ShowStatementOptions, } /// MSSQL's json null clause /// /// ```plaintext /// ::= /// NULL ON NULL /// | ABSENT ON NULL /// ``` /// /// #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum JsonNullClause { /// `NULL ON NULL` behavior for JSON functions. NullOnNull, /// `ABSENT ON NULL` behavior for JSON functions. AbsentOnNull, } impl Display for JsonNullClause { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { JsonNullClause::NullOnNull => write!(f, "NULL ON NULL"), JsonNullClause::AbsentOnNull => write!(f, "ABSENT ON NULL"), } } } /// PostgreSQL JSON function RETURNING clause /// /// Example: /// ```sql /// JSON_OBJECT('a': 1 RETURNING jsonb) /// ``` #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct JsonReturningClause { /// The data type to return from the JSON function (e.g. JSON/JSONB). pub data_type: DataType, } impl Display for JsonReturningClause { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "RETURNING {}", self.data_type) } } /// rename object definition #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct RenameTable { /// The current name of the object to rename. pub old_name: ObjectName, /// The new name for the object. pub new_name: ObjectName, } impl fmt::Display for RenameTable { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{} TO {}", self.old_name, self.new_name)?; Ok(()) } } /// Represents the referenced table in an `INSERT INTO` statement #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum TableObject { /// Table specified by name. /// Example: /// ```sql /// INSERT INTO my_table /// ``` TableName(#[cfg_attr(feature = "visitor", visit(with = "visit_relation"))] ObjectName), /// Table specified as a function. /// Example: /// ```sql /// INSERT INTO TABLE FUNCTION remote('localhost', default.simple_table) /// ``` /// [Clickhouse](https://clickhouse.com/docs/en/sql-reference/table-functions) TableFunction(Function), /// Table specified through a sub-query /// Example: /// ```sql /// INSERT INTO /// (SELECT employee_id, last_name, email, hire_date, job_id, salary, commission_pct FROM employees) /// VALUES (207, 'Gregory', 'pgregory@example.com', sysdate, 'PU_CLERK', 1.2E3, NULL); /// ``` /// [Oracle](https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/INSERT.html#GUID-903F8043-0254-4EE9-ACC1-CB8AC0AF3423__I2126242) TableQuery(Box), } impl fmt::Display for TableObject { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { Self::TableName(table_name) => write!(f, "{table_name}"), Self::TableFunction(func) => write!(f, "FUNCTION {func}"), Self::TableQuery(table_query) => write!(f, "({table_query})"), } } } /// Represents a SET SESSION AUTHORIZATION statement #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct SetSessionAuthorizationParam { /// The scope for the `SET SESSION AUTHORIZATION` (e.g., GLOBAL/SESSION). pub scope: ContextModifier, /// The specific authorization parameter kind. pub kind: SetSessionAuthorizationParamKind, } impl fmt::Display for SetSessionAuthorizationParam { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{}", self.kind) } } /// Represents the parameter kind for SET SESSION AUTHORIZATION #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum SetSessionAuthorizationParamKind { /// Default authorization Default, /// User name User(Ident), } impl fmt::Display for SetSessionAuthorizationParamKind { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { SetSessionAuthorizationParamKind::Default => write!(f, "DEFAULT"), SetSessionAuthorizationParamKind::User(name) => write!(f, "{}", name), } } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Kind of session parameter being set by `SET SESSION`. pub enum SetSessionParamKind { /// Generic session parameter (name/value pair). Generic(SetSessionParamGeneric), /// Identity insert related parameter. IdentityInsert(SetSessionParamIdentityInsert), /// Offsets-related parameter. Offsets(SetSessionParamOffsets), /// Statistics-related parameter. Statistics(SetSessionParamStatistics), } impl fmt::Display for SetSessionParamKind { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { SetSessionParamKind::Generic(x) => write!(f, "{x}"), SetSessionParamKind::IdentityInsert(x) => write!(f, "{x}"), SetSessionParamKind::Offsets(x) => write!(f, "{x}"), SetSessionParamKind::Statistics(x) => write!(f, "{x}"), } } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Generic `SET SESSION` parameter represented as name(s) and value. pub struct SetSessionParamGeneric { /// Names of the session parameters being set. pub names: Vec, /// The value to assign to the parameter(s). pub value: String, } impl fmt::Display for SetSessionParamGeneric { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{} {}", display_comma_separated(&self.names), self.value) } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// `IDENTITY_INSERT` session parameter for a specific object. pub struct SetSessionParamIdentityInsert { /// Object name targeted by `IDENTITY_INSERT`. pub obj: ObjectName, /// Value (ON/OFF) for the identity insert setting. pub value: SessionParamValue, } impl fmt::Display for SetSessionParamIdentityInsert { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "IDENTITY_INSERT {} {}", self.obj, self.value) } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Offsets-related session parameter with keywords and a value. pub struct SetSessionParamOffsets { /// Keywords specifying which offsets to modify. pub keywords: Vec, /// Value (ON/OFF) for the offsets setting. pub value: SessionParamValue, } impl fmt::Display for SetSessionParamOffsets { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "OFFSETS {} {}", display_comma_separated(&self.keywords), self.value ) } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Statistics-related session parameter specifying topic and value. pub struct SetSessionParamStatistics { /// Statistics topic to set (IO/PROFILE/TIME/XML). pub topic: SessionParamStatsTopic, /// Value (ON/OFF) for the statistics topic. pub value: SessionParamValue, } impl fmt::Display for SetSessionParamStatistics { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "STATISTICS {} {}", self.topic, self.value) } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Topics available for session statistics configuration. pub enum SessionParamStatsTopic { /// Input/output statistics. IO, /// Profile statistics. Profile, /// Time statistics. Time, /// XML-related statistics. Xml, } impl fmt::Display for SessionParamStatsTopic { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { SessionParamStatsTopic::IO => write!(f, "IO"), SessionParamStatsTopic::Profile => write!(f, "PROFILE"), SessionParamStatsTopic::Time => write!(f, "TIME"), SessionParamStatsTopic::Xml => write!(f, "XML"), } } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Value for a session boolean-like parameter (ON/OFF). pub enum SessionParamValue { /// Session parameter enabled. On, /// Session parameter disabled. Off, } impl fmt::Display for SessionParamValue { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { SessionParamValue::On => write!(f, "ON"), SessionParamValue::Off => write!(f, "OFF"), } } } /// Snowflake StorageSerializationPolicy for Iceberg Tables /// ```sql /// [ STORAGE_SERIALIZATION_POLICY = { COMPATIBLE | OPTIMIZED } ] /// ``` /// /// #[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 StorageSerializationPolicy { /// Use compatible serialization mode. Compatible, /// Use optimized serialization mode. Optimized, } impl Display for StorageSerializationPolicy { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { StorageSerializationPolicy::Compatible => write!(f, "COMPATIBLE"), StorageSerializationPolicy::Optimized => write!(f, "OPTIMIZED"), } } } /// Snowflake CatalogSyncNamespaceMode /// ```sql /// [ CATALOG_SYNC_NAMESPACE_MODE = { NEST | FLATTEN } ] /// ``` /// /// #[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 CatalogSyncNamespaceMode { /// Nest namespaces when syncing catalog. Nest, /// Flatten namespaces when syncing catalog. Flatten, } impl Display for CatalogSyncNamespaceMode { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { CatalogSyncNamespaceMode::Nest => write!(f, "NEST"), CatalogSyncNamespaceMode::Flatten => write!(f, "FLATTEN"), } } } /// Variants of the Snowflake `COPY INTO` statement #[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 CopyIntoSnowflakeKind { /// Loads data from files to a table /// See: Table, /// Unloads data from a table or query to external files /// See: Location, } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// `PRINT` statement for producing debug/output messages. pub struct PrintStatement { /// The expression producing the message to print. pub message: Box, } impl fmt::Display for PrintStatement { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "PRINT {}", self.message) } } /// The type of `WAITFOR` statement (MSSQL). /// /// See: #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum WaitForType { /// `WAITFOR DELAY 'time_to_pass'` Delay, /// `WAITFOR TIME 'time_to_execute'` Time, } impl fmt::Display for WaitForType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { WaitForType::Delay => write!(f, "DELAY"), WaitForType::Time => write!(f, "TIME"), } } } /// MSSQL `WAITFOR` statement. /// /// See: #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct WaitForStatement { /// `DELAY` or `TIME`. pub wait_type: WaitForType, /// The time expression. pub expr: Expr, } impl fmt::Display for WaitForStatement { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "WAITFOR {} {}", self.wait_type, self.expr) } } /// Represents a `Return` statement. /// /// [MsSql triggers](https://learn.microsoft.com/en-us/sql/t-sql/statements/create-trigger-transact-sql) /// [MsSql functions](https://learn.microsoft.com/en-us/sql/t-sql/statements/create-function-transact-sql) #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct ReturnStatement { /// Optional return value expression. pub value: Option, } impl fmt::Display for ReturnStatement { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match &self.value { Some(ReturnStatementValue::Expr(expr)) => write!(f, "RETURN {expr}"), None => write!(f, "RETURN"), } } } /// Variants of a `RETURN` statement #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum ReturnStatementValue { /// Return an expression from a function or trigger. Expr(Expr), } /// Represents an `OPEN` statement. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct OpenStatement { /// Cursor name pub cursor_name: Ident, } impl fmt::Display for OpenStatement { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "OPEN {}", self.cursor_name) } } /// Specifies Include / Exclude NULL within UNPIVOT command. /// For example /// `UNPIVOT (column1 FOR new_column IN (col3, col4, col5, col6))` #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum NullInclusion { /// Include NULL values in the UNPIVOT output. IncludeNulls, /// Exclude NULL values from the UNPIVOT output. ExcludeNulls, } impl fmt::Display for NullInclusion { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { NullInclusion::IncludeNulls => write!(f, "INCLUDE NULLS"), NullInclusion::ExcludeNulls => write!(f, "EXCLUDE NULLS"), } } } /// Checks membership of a value in a JSON array /// /// Syntax: /// ```sql /// MEMBER OF() /// ``` /// [MySQL](https://dev.mysql.com/doc/refman/8.4/en/json-search-functions.html#operator_member-of) #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct MemberOf { /// The value to check for membership. pub value: Box, /// The JSON array expression to check against. pub array: Box, } impl fmt::Display for MemberOf { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{} MEMBER OF({})", self.value, self.array) } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Represents an `EXPORT DATA` statement. pub struct ExportData { /// Options for the export operation. pub options: Vec, /// The query producing the data to export. pub query: Box, /// Optional named connection to use for export. pub connection: Option, } impl fmt::Display for ExportData { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { if let Some(connection) = &self.connection { write!( f, "EXPORT DATA WITH CONNECTION {connection} OPTIONS({}) AS {}", display_comma_separated(&self.options), self.query ) } else { write!( f, "EXPORT DATA OPTIONS({}) AS {}", display_comma_separated(&self.options), self.query ) } } } /// Creates a user /// /// Syntax: /// ```sql /// CREATE [OR REPLACE] USER [IF NOT EXISTS] [OPTIONS] /// ``` /// /// [Snowflake](https://docs.snowflake.com/en/sql-reference/sql/create-user) #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct CreateUser { /// Replace existing user if present. pub or_replace: bool, /// Only create the user if it does not already exist. pub if_not_exists: bool, /// The name of the user to create. pub name: Ident, /// Key/value options for user creation. pub options: KeyValueOptions, /// Whether tags are specified using `WITH TAG`. pub with_tags: bool, /// Tags for the user. pub tags: KeyValueOptions, } impl fmt::Display for CreateUser { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "CREATE")?; if self.or_replace { write!(f, " OR REPLACE")?; } write!(f, " USER")?; if self.if_not_exists { write!(f, " IF NOT EXISTS")?; } write!(f, " {}", self.name)?; if !self.options.options.is_empty() { write!(f, " {}", self.options)?; } if !self.tags.options.is_empty() { if self.with_tags { write!(f, " WITH")?; } write!(f, " TAG ({})", self.tags)?; } Ok(()) } } /// Modifies the properties of a user /// /// [Snowflake Syntax:](https://docs.snowflake.com/en/sql-reference/sql/alter-user) /// ```sql /// ALTER USER [ IF EXISTS ] [ ] [ OPTIONS ] /// ``` /// /// [PostgreSQL Syntax:](https://www.postgresql.org/docs/current/sql-alteruser.html) /// ```sql /// ALTER USER [ WITH ] option [ ... ] /// ``` #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct AlterUser { /// Whether to only alter the user if it exists. pub if_exists: bool, /// The name of the user to alter. pub name: Ident, /// Optional new name for the user (Snowflake-specific). /// See: pub rename_to: Option, /// Reset the user's password. pub reset_password: bool, /// Abort all running queries for the user. pub abort_all_queries: bool, /// Optionally add a delegated role authorization. pub add_role_delegation: Option, /// Optionally remove a delegated role authorization. pub remove_role_delegation: Option, /// Enroll the user in MFA. pub enroll_mfa: bool, /// Set the default MFA method for the user. pub set_default_mfa_method: Option, /// Remove the user's default MFA method. pub remove_mfa_method: Option, /// Modify an MFA method for the user. pub modify_mfa_method: Option, /// Add an MFA OTP method with optional count. pub add_mfa_method_otp: Option, /// Set a user policy. pub set_policy: Option, /// Unset a user policy. pub unset_policy: Option, /// Key/value tag options to set on the user. pub set_tag: KeyValueOptions, /// Tags to unset on the user. pub unset_tag: Vec, /// Key/value properties to set on the user. pub set_props: KeyValueOptions, /// Properties to unset on the user. pub unset_props: Vec, /// The following options are PostgreSQL-specific: pub password: Option, } /// ```sql /// ALTER USER [ IF EXISTS ] [ ] ADD DELEGATED AUTHORIZATION OF ROLE TO SECURITY INTEGRATION /// ``` #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct AlterUserAddRoleDelegation { /// Role name to delegate. pub role: Ident, /// Security integration receiving the delegation. pub integration: Ident, } /// ```sql /// ALTER USER [ IF EXISTS ] [ ] REMOVE DELEGATED { AUTHORIZATION OF ROLE | AUTHORIZATIONS } FROM SECURITY INTEGRATION /// ``` #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct AlterUserRemoveRoleDelegation { /// Optional role name to remove delegation for. pub role: Option, /// Security integration from which to remove delegation. pub integration: Ident, } /// ```sql /// ADD MFA METHOD OTP [ COUNT = number ] /// ``` #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct AlterUserAddMfaMethodOtp { /// Optional OTP count parameter. pub count: Option, } /// ```sql /// ALTER USER [ IF EXISTS ] [ ] MODIFY MFA METHOD SET COMMENT = '' /// ``` #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct AlterUserModifyMfaMethod { /// The MFA method being modified. pub method: MfaMethodKind, /// The new comment for the MFA method. pub comment: String, } /// Types of MFA methods #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum MfaMethodKind { /// PassKey (hardware or platform passkey) MFA method. PassKey, /// Time-based One-Time Password (TOTP) MFA method. Totp, /// Duo Security MFA method. Duo, } impl fmt::Display for MfaMethodKind { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { MfaMethodKind::PassKey => write!(f, "PASSKEY"), MfaMethodKind::Totp => write!(f, "TOTP"), MfaMethodKind::Duo => write!(f, "DUO"), } } } /// ```sql /// ALTER USER [ IF EXISTS ] [ ] SET { AUTHENTICATION | PASSWORD | SESSION } POLICY /// ``` #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct AlterUserSetPolicy { /// The kind of user policy being set (authentication/password/session). pub policy_kind: UserPolicyKind, /// The identifier of the policy to apply. pub policy: Ident, } /// Types of user-based policies #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum UserPolicyKind { /// Authentication policy. Authentication, /// Password policy. Password, /// Session policy. Session, } impl fmt::Display for UserPolicyKind { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { UserPolicyKind::Authentication => write!(f, "AUTHENTICATION"), UserPolicyKind::Password => write!(f, "PASSWORD"), UserPolicyKind::Session => write!(f, "SESSION"), } } } impl fmt::Display for AlterUser { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "ALTER")?; write!(f, " USER")?; if self.if_exists { write!(f, " IF EXISTS")?; } write!(f, " {}", self.name)?; if let Some(new_name) = &self.rename_to { write!(f, " RENAME TO {new_name}")?; } if self.reset_password { write!(f, " RESET PASSWORD")?; } if self.abort_all_queries { write!(f, " ABORT ALL QUERIES")?; } if let Some(role_delegation) = &self.add_role_delegation { let role = &role_delegation.role; let integration = &role_delegation.integration; write!( f, " ADD DELEGATED AUTHORIZATION OF ROLE {role} TO SECURITY INTEGRATION {integration}" )?; } if let Some(role_delegation) = &self.remove_role_delegation { write!(f, " REMOVE DELEGATED")?; match &role_delegation.role { Some(role) => write!(f, " AUTHORIZATION OF ROLE {role}")?, None => write!(f, " AUTHORIZATIONS")?, } let integration = &role_delegation.integration; write!(f, " FROM SECURITY INTEGRATION {integration}")?; } if self.enroll_mfa { write!(f, " ENROLL MFA")?; } if let Some(method) = &self.set_default_mfa_method { write!(f, " SET DEFAULT_MFA_METHOD {method}")? } if let Some(method) = &self.remove_mfa_method { write!(f, " REMOVE MFA METHOD {method}")?; } if let Some(modify) = &self.modify_mfa_method { let method = &modify.method; let comment = &modify.comment; write!( f, " MODIFY MFA METHOD {method} SET COMMENT '{}'", value::escape_single_quote_string(comment) )?; } if let Some(add_mfa_method_otp) = &self.add_mfa_method_otp { write!(f, " ADD MFA METHOD OTP")?; if let Some(count) = &add_mfa_method_otp.count { write!(f, " COUNT = {count}")?; } } if let Some(policy) = &self.set_policy { let policy_kind = &policy.policy_kind; let name = &policy.policy; write!(f, " SET {policy_kind} POLICY {name}")?; } if let Some(policy_kind) = &self.unset_policy { write!(f, " UNSET {policy_kind} POLICY")?; } if !self.set_tag.options.is_empty() { write!(f, " SET TAG {}", self.set_tag)?; } if !self.unset_tag.is_empty() { write!(f, " UNSET TAG {}", display_comma_separated(&self.unset_tag))?; } let has_props = !self.set_props.options.is_empty(); if has_props { write!(f, " SET")?; write!(f, " {}", &self.set_props)?; } if !self.unset_props.is_empty() { write!(f, " UNSET {}", display_comma_separated(&self.unset_props))?; } if let Some(password) = &self.password { write!(f, " {}", password)?; } Ok(()) } } /// ```sql /// ALTER USER [ WITH ] PASSWORD { 'password' | NULL }`` /// ``` #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct AlterUserPassword { /// Whether the password is encrypted. pub encrypted: bool, /// The password string, or `None` for `NULL`. pub password: Option, } impl Display for AlterUserPassword { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { if self.encrypted { write!(f, "ENCRYPTED ")?; } write!(f, "PASSWORD")?; match &self.password { None => write!(f, " NULL")?, Some(password) => write!(f, " '{}'", value::escape_single_quote_string(password))?, } Ok(()) } } /// Specifies how to create a new table based on an existing table's schema. /// '''sql /// CREATE TABLE new LIKE old ... /// ''' #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum CreateTableLikeKind { /// '''sql /// CREATE TABLE new (LIKE old ...) /// ''' /// [Redshift](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_TABLE_NEW.html) Parenthesized(CreateTableLike), /// '''sql /// CREATE TABLE new LIKE old ... /// ''' /// [Snowflake](https://docs.snowflake.com/en/sql-reference/sql/create-table#label-create-table-like) /// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language#create_table_like) Plain(CreateTableLike), } #[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Controls whether defaults are included when creating a table FROM/LILE another. pub enum CreateTableLikeDefaults { /// Include default values from the source table. Including, /// Exclude default values from the source table. Excluding, } impl fmt::Display for CreateTableLikeDefaults { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { CreateTableLikeDefaults::Including => write!(f, "INCLUDING DEFAULTS"), CreateTableLikeDefaults::Excluding => write!(f, "EXCLUDING DEFAULTS"), } } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Represents the `LIKE` clause of a `CREATE TABLE` statement. pub struct CreateTableLike { /// The source table name to copy the schema from. pub name: ObjectName, /// Optional behavior controlling whether defaults are copied. pub defaults: Option, } impl fmt::Display for CreateTableLike { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "LIKE {}", self.name)?; if let Some(defaults) = &self.defaults { write!(f, " {defaults}")?; } Ok(()) } } /// Specifies the refresh mode for the dynamic table. /// /// [Snowflake](https://docs.snowflake.com/en/sql-reference/sql/create-dynamic-table) #[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 RefreshModeKind { /// Automatic refresh mode (`AUTO`). Auto, /// Full refresh mode (`FULL`). Full, /// Incremental refresh mode (`INCREMENTAL`). Incremental, } impl fmt::Display for RefreshModeKind { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { RefreshModeKind::Auto => write!(f, "AUTO"), RefreshModeKind::Full => write!(f, "FULL"), RefreshModeKind::Incremental => write!(f, "INCREMENTAL"), } } } /// Specifies the behavior of the initial refresh of the dynamic table. /// /// [Snowflake](https://docs.snowflake.com/en/sql-reference/sql/create-dynamic-table) #[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 InitializeKind { /// Initialize on creation (`ON CREATE`). OnCreate, /// Initialize on schedule (`ON SCHEDULE`). OnSchedule, } impl fmt::Display for InitializeKind { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { InitializeKind::OnCreate => write!(f, "ON_CREATE"), InitializeKind::OnSchedule => write!(f, "ON_SCHEDULE"), } } } /// Re-sorts rows and reclaims space in either a specified table or all tables in the current database /// /// '''sql /// VACUUM [ FULL | SORT ONLY | DELETE ONLY | REINDEX | RECLUSTER ] [ \[ table_name \] [ TO threshold PERCENT ] \[ BOOST \] ] /// ''' /// [Redshift](https://docs.aws.amazon.com/redshift/latest/dg/r_VACUUM_command.html) #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct VacuumStatement { /// Whether `FULL` was specified. pub full: bool, /// Whether `SORT ONLY` was specified. pub sort_only: bool, /// Whether `DELETE ONLY` was specified. pub delete_only: bool, /// Whether `REINDEX` was specified. pub reindex: bool, /// Whether `RECLUSTER` was specified. pub recluster: bool, /// Optional table to run `VACUUM` on. pub table_name: Option, /// Optional threshold value (percent) for `TO threshold PERCENT`. pub threshold: Option, /// Whether `BOOST` was specified. pub boost: bool, } impl fmt::Display for VacuumStatement { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "VACUUM{}{}{}{}{}", if self.full { " FULL" } else { "" }, if self.sort_only { " SORT ONLY" } else { "" }, if self.delete_only { " DELETE ONLY" } else { "" }, if self.reindex { " REINDEX" } else { "" }, if self.recluster { " RECLUSTER" } else { "" }, )?; if let Some(table_name) = &self.table_name { write!(f, " {table_name}")?; } if let Some(threshold) = &self.threshold { write!(f, " TO {threshold} PERCENT")?; } if self.boost { write!(f, " BOOST")?; } Ok(()) } } /// Variants of the RESET statement #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum Reset { /// Resets all session parameters to their default values. ALL, /// Resets a specific session parameter to its default value. ConfigurationParameter(ObjectName), } /// Resets a session parameter to its default value. /// ```sql /// RESET { ALL | } /// ``` #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct ResetStatement { /// The reset action to perform (either `ALL` or a specific configuration parameter). pub reset: Reset, } /// Query optimizer hints are optionally supported comments after the /// `SELECT`, `INSERT`, `UPDATE`, `REPLACE`, `MERGE`, and `DELETE` keywords in /// the corresponding statements. /// /// See [Select::optimizer_hints] #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct OptimizerHint { /// An optional prefix between the comment marker and `+`. /// /// Standard optimizer hints like `/*+ ... */` have an empty prefix, /// while system-specific hints like `/*abc+ ... */` have `prefix = "abc"`. /// The prefix is any sequence of ASCII alphanumeric characters /// immediately before the `+` marker. pub prefix: String, /// the raw text of the optimizer hint without its markers pub text: String, /// the style of the comment which `text` was extracted from, /// e.g. `/*+...*/` or `--+...` /// /// Not all dialects support all styles, though. pub style: OptimizerHintStyle, } /// The commentary style of an [optimizer hint](OptimizerHint) #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum OptimizerHintStyle { /// A hint corresponding to a single line comment, /// e.g. `--+ LEADING(v.e v.d t)` SingleLine { /// the comment prefix, e.g. `--` prefix: String, }, /// A hint corresponding to a multi line comment, /// e.g. `/*+ LEADING(v.e v.d t) */` MultiLine, } impl fmt::Display for OptimizerHint { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match &self.style { OptimizerHintStyle::SingleLine { prefix } => { f.write_str(prefix)?; f.write_str(&self.prefix)?; f.write_str("+")?; f.write_str(&self.text) } OptimizerHintStyle::MultiLine => { f.write_str("/*")?; f.write_str(&self.prefix)?; f.write_str("+")?; f.write_str(&self.text)?; f.write_str("*/") } } } } impl fmt::Display for ResetStatement { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match &self.reset { Reset::ALL => write!(f, "RESET ALL"), Reset::ConfigurationParameter(param) => write!(f, "RESET {}", param), } } } impl From for Statement { fn from(s: Set) -> Self { Self::Set(s) } } impl From for Statement { fn from(q: Query) -> Self { Box::new(q).into() } } impl From> for Statement { fn from(q: Box) -> Self { Self::Query(q) } } impl From for Statement { fn from(i: Insert) -> Self { Self::Insert(i) } } impl From for Statement { fn from(u: Update) -> Self { Self::Update(u) } } impl From for Statement { fn from(cv: CreateView) -> Self { Self::CreateView(cv) } } impl From for Statement { fn from(cr: CreateRole) -> Self { Self::CreateRole(cr) } } impl From for Statement { fn from(at: AlterTable) -> Self { Self::AlterTable(at) } } impl From for Statement { fn from(df: DropFunction) -> Self { Self::DropFunction(df) } } impl From for Statement { fn from(ce: CreateExtension) -> Self { Self::CreateExtension(ce) } } impl From for Statement { fn from(c: CreateCollation) -> Self { Self::CreateCollation(c) } } impl From for Statement { fn from(de: DropExtension) -> Self { Self::DropExtension(de) } } impl From for Statement { fn from(c: CaseStatement) -> Self { Self::Case(c) } } impl From for Statement { fn from(i: IfStatement) -> Self { Self::If(i) } } impl From for Statement { fn from(w: WhileStatement) -> Self { Self::While(w) } } impl From for Statement { fn from(r: RaiseStatement) -> Self { Self::Raise(r) } } impl From for Statement { fn from(t: ThrowStatement) -> Self { Self::Throw(t) } } impl From for Statement { fn from(f: Function) -> Self { Self::Call(f) } } impl From for Statement { fn from(o: OpenStatement) -> Self { Self::Open(o) } } impl From for Statement { fn from(d: Delete) -> Self { Self::Delete(d) } } impl From for Statement { fn from(c: CreateTable) -> Self { Self::CreateTable(c) } } impl From for Statement { fn from(c: CreateIndex) -> Self { Self::CreateIndex(c) } } impl From for Statement { fn from(c: CreateServerStatement) -> Self { Self::CreateServer(c) } } impl From for Statement { fn from(c: CreateConnector) -> Self { Self::CreateConnector(c) } } impl From for Statement { fn from(c: CreateOperator) -> Self { Self::CreateOperator(c) } } impl From for Statement { fn from(c: CreateOperatorFamily) -> Self { Self::CreateOperatorFamily(c) } } impl From for Statement { fn from(c: CreateOperatorClass) -> Self { Self::CreateOperatorClass(c) } } impl From for Statement { fn from(a: AlterSchema) -> Self { Self::AlterSchema(a) } } impl From for Statement { fn from(a: AlterFunction) -> Self { Self::AlterFunction(a) } } impl From for Statement { fn from(a: AlterType) -> Self { Self::AlterType(a) } } impl From for Statement { fn from(a: AlterCollation) -> Self { Self::AlterCollation(a) } } impl From for Statement { fn from(a: AlterOperator) -> Self { Self::AlterOperator(a) } } impl From for Statement { fn from(a: AlterOperatorFamily) -> Self { Self::AlterOperatorFamily(a) } } impl From for Statement { fn from(a: AlterOperatorClass) -> Self { Self::AlterOperatorClass(a) } } impl From for Statement { fn from(m: Merge) -> Self { Self::Merge(m) } } impl From for Statement { fn from(a: AlterUser) -> Self { Self::AlterUser(a) } } impl From for Statement { fn from(d: DropDomain) -> Self { Self::DropDomain(d) } } impl From for Statement { fn from(s: ShowCharset) -> Self { Self::ShowCharset(s) } } impl From for Statement { fn from(s: ShowObjects) -> Self { Self::ShowObjects(s) } } impl From for Statement { fn from(u: Use) -> Self { Self::Use(u) } } impl From for Statement { fn from(c: CreateFunction) -> Self { Self::CreateFunction(c) } } impl From for Statement { fn from(c: CreateTrigger) -> Self { Self::CreateTrigger(c) } } impl From for Statement { fn from(d: DropTrigger) -> Self { Self::DropTrigger(d) } } impl From for Statement { fn from(d: DropOperator) -> Self { Self::DropOperator(d) } } impl From for Statement { fn from(d: DropOperatorFamily) -> Self { Self::DropOperatorFamily(d) } } impl From for Statement { fn from(d: DropOperatorClass) -> Self { Self::DropOperatorClass(d) } } impl From for Statement { fn from(d: DenyStatement) -> Self { Self::Deny(d) } } impl From for Statement { fn from(c: CreateDomain) -> Self { Self::CreateDomain(c) } } impl From for Statement { fn from(r: RenameTable) -> Self { vec![r].into() } } impl From> for Statement { fn from(r: Vec) -> Self { Self::RenameTable(r) } } impl From for Statement { fn from(p: PrintStatement) -> Self { Self::Print(p) } } impl From for Statement { fn from(r: ReturnStatement) -> Self { Self::Return(r) } } impl From for Statement { fn from(e: ExportData) -> Self { Self::ExportData(e) } } impl From for Statement { fn from(c: CreateUser) -> Self { Self::CreateUser(c) } } impl From for Statement { fn from(v: VacuumStatement) -> Self { Self::Vacuum(v) } } impl From for Statement { fn from(r: ResetStatement) -> Self { Self::Reset(r) } } #[cfg(test)] mod tests { use crate::tokenizer::Location; use super::*; #[test] fn test_window_frame_default() { let window_frame = WindowFrame::default(); assert_eq!(WindowFrameBound::Preceding(None), window_frame.start_bound); } #[test] fn test_grouping_sets_display() { // a and b in different group let grouping_sets = Expr::GroupingSets(vec![ vec![Expr::Identifier(Ident::new("a"))], vec![Expr::Identifier(Ident::new("b"))], ]); assert_eq!("GROUPING SETS ((a), (b))", format!("{grouping_sets}")); // a and b in the same group let grouping_sets = Expr::GroupingSets(vec![vec![ Expr::Identifier(Ident::new("a")), Expr::Identifier(Ident::new("b")), ]]); assert_eq!("GROUPING SETS ((a, b))", format!("{grouping_sets}")); // (a, b) and (c, d) in different group let grouping_sets = Expr::GroupingSets(vec![ vec![ Expr::Identifier(Ident::new("a")), Expr::Identifier(Ident::new("b")), ], vec![ Expr::Identifier(Ident::new("c")), Expr::Identifier(Ident::new("d")), ], ]); assert_eq!("GROUPING SETS ((a, b), (c, d))", format!("{grouping_sets}")); } #[test] fn test_rollup_display() { let rollup = Expr::Rollup(vec![vec![Expr::Identifier(Ident::new("a"))]]); assert_eq!("ROLLUP (a)", format!("{rollup}")); let rollup = Expr::Rollup(vec![vec![ Expr::Identifier(Ident::new("a")), Expr::Identifier(Ident::new("b")), ]]); assert_eq!("ROLLUP ((a, b))", format!("{rollup}")); let rollup = Expr::Rollup(vec![ vec![Expr::Identifier(Ident::new("a"))], vec![Expr::Identifier(Ident::new("b"))], ]); assert_eq!("ROLLUP (a, b)", format!("{rollup}")); let rollup = Expr::Rollup(vec![ vec![Expr::Identifier(Ident::new("a"))], vec![ Expr::Identifier(Ident::new("b")), Expr::Identifier(Ident::new("c")), ], vec![Expr::Identifier(Ident::new("d"))], ]); assert_eq!("ROLLUP (a, (b, c), d)", format!("{rollup}")); } #[test] fn test_cube_display() { let cube = Expr::Cube(vec![vec![Expr::Identifier(Ident::new("a"))]]); assert_eq!("CUBE (a)", format!("{cube}")); let cube = Expr::Cube(vec![vec![ Expr::Identifier(Ident::new("a")), Expr::Identifier(Ident::new("b")), ]]); assert_eq!("CUBE ((a, b))", format!("{cube}")); let cube = Expr::Cube(vec![ vec![Expr::Identifier(Ident::new("a"))], vec![Expr::Identifier(Ident::new("b"))], ]); assert_eq!("CUBE (a, b)", format!("{cube}")); let cube = Expr::Cube(vec![ vec![Expr::Identifier(Ident::new("a"))], vec![ Expr::Identifier(Ident::new("b")), Expr::Identifier(Ident::new("c")), ], vec![Expr::Identifier(Ident::new("d"))], ]); assert_eq!("CUBE (a, (b, c), d)", format!("{cube}")); } #[test] fn test_interval_display() { let interval = Expr::Interval(Interval { value: Box::new(Expr::Value( Value::SingleQuotedString(String::from("123:45.67")).with_empty_span(), )), leading_field: Some(DateTimeField::Minute), leading_precision: Some(10), last_field: Some(DateTimeField::Second), fractional_seconds_precision: Some(9), }); assert_eq!( "INTERVAL '123:45.67' MINUTE (10) TO SECOND (9)", format!("{interval}"), ); let interval = Expr::Interval(Interval { value: Box::new(Expr::Value( Value::SingleQuotedString(String::from("5")).with_empty_span(), )), leading_field: Some(DateTimeField::Second), leading_precision: Some(1), last_field: None, fractional_seconds_precision: Some(3), }); assert_eq!("INTERVAL '5' SECOND (1, 3)", format!("{interval}")); } #[test] fn test_one_or_many_with_parens_deref() { use core::ops::Index; let one = OneOrManyWithParens::One("a"); assert_eq!(one.deref(), &["a"]); assert_eq!( as Deref>::deref(&one), &["a"]); assert_eq!(one[0], "a"); assert_eq!(one.index(0), &"a"); assert_eq!( < as Deref>::Target as Index>::index(&one, 0), &"a" ); assert_eq!(one.len(), 1); assert_eq!( as Deref>::Target::len(&one), 1); let many1 = OneOrManyWithParens::Many(vec!["b"]); assert_eq!(many1.deref(), &["b"]); assert_eq!( as Deref>::deref(&many1), &["b"]); assert_eq!(many1[0], "b"); assert_eq!(many1.index(0), &"b"); assert_eq!( < as Deref>::Target as Index>::index(&many1, 0), &"b" ); assert_eq!(many1.len(), 1); assert_eq!( as Deref>::Target::len(&many1), 1); let many2 = OneOrManyWithParens::Many(vec!["c", "d"]); assert_eq!(many2.deref(), &["c", "d"]); assert_eq!( as Deref>::deref(&many2), &["c", "d"] ); assert_eq!(many2[0], "c"); assert_eq!(many2.index(0), &"c"); assert_eq!( < as Deref>::Target as Index>::index(&many2, 0), &"c" ); assert_eq!(many2[1], "d"); assert_eq!(many2.index(1), &"d"); assert_eq!( < as Deref>::Target as Index>::index(&many2, 1), &"d" ); assert_eq!(many2.len(), 2); assert_eq!( as Deref>::Target::len(&many2), 2); } #[test] fn test_one_or_many_with_parens_as_ref() { let one = OneOrManyWithParens::One("a"); assert_eq!(one.as_ref(), &["a"]); assert_eq!( as AsRef<_>>::as_ref(&one), &["a"]); let many1 = OneOrManyWithParens::Many(vec!["b"]); assert_eq!(many1.as_ref(), &["b"]); assert_eq!( as AsRef<_>>::as_ref(&many1), &["b"]); let many2 = OneOrManyWithParens::Many(vec!["c", "d"]); assert_eq!(many2.as_ref(), &["c", "d"]); assert_eq!( as AsRef<_>>::as_ref(&many2), &["c", "d"] ); } #[test] fn test_one_or_many_with_parens_ref_into_iter() { let one = OneOrManyWithParens::One("a"); assert_eq!(Vec::from_iter(&one), vec![&"a"]); let many1 = OneOrManyWithParens::Many(vec!["b"]); assert_eq!(Vec::from_iter(&many1), vec![&"b"]); let many2 = OneOrManyWithParens::Many(vec!["c", "d"]); assert_eq!(Vec::from_iter(&many2), vec![&"c", &"d"]); } #[test] fn test_one_or_many_with_parens_value_into_iter() { use core::iter::once; //tests that our iterator implemented methods behaves exactly as it's inner iterator, at every step up to n calls to next/next_back fn test_steps(ours: OneOrManyWithParens, inner: I, n: usize) where I: IntoIterator + Clone, { fn checks(ours: OneOrManyWithParensIntoIter, inner: I) where I: Iterator + Clone + DoubleEndedIterator, { assert_eq!(ours.size_hint(), inner.size_hint()); assert_eq!(ours.clone().count(), inner.clone().count()); assert_eq!( ours.clone().fold(1, |a, v| a + v), inner.clone().fold(1, |a, v| a + v) ); assert_eq!(Vec::from_iter(ours.clone()), Vec::from_iter(inner.clone())); assert_eq!( Vec::from_iter(ours.clone().rev()), Vec::from_iter(inner.clone().rev()) ); } let mut ours_next = ours.clone().into_iter(); let mut inner_next = inner.clone().into_iter(); for _ in 0..n { checks(ours_next.clone(), inner_next.clone()); assert_eq!(ours_next.next(), inner_next.next()); } let mut ours_next_back = ours.clone().into_iter(); let mut inner_next_back = inner.clone().into_iter(); for _ in 0..n { checks(ours_next_back.clone(), inner_next_back.clone()); assert_eq!(ours_next_back.next_back(), inner_next_back.next_back()); } let mut ours_mixed = ours.clone().into_iter(); let mut inner_mixed = inner.clone().into_iter(); for i in 0..n { checks(ours_mixed.clone(), inner_mixed.clone()); if i % 2 == 0 { assert_eq!(ours_mixed.next_back(), inner_mixed.next_back()); } else { assert_eq!(ours_mixed.next(), inner_mixed.next()); } } let mut ours_mixed2 = ours.into_iter(); let mut inner_mixed2 = inner.into_iter(); for i in 0..n { checks(ours_mixed2.clone(), inner_mixed2.clone()); if i % 2 == 0 { assert_eq!(ours_mixed2.next(), inner_mixed2.next()); } else { assert_eq!(ours_mixed2.next_back(), inner_mixed2.next_back()); } } } test_steps(OneOrManyWithParens::One(1), once(1), 3); test_steps(OneOrManyWithParens::Many(vec![2]), vec![2], 3); test_steps(OneOrManyWithParens::Many(vec![3, 4]), vec![3, 4], 4); } // Tests that the position in the code of an `Ident` does not affect its // ordering. #[test] fn test_ident_ord() { let mut a = Ident::with_span(Span::new(Location::new(1, 1), Location::new(1, 1)), "a"); let mut b = Ident::with_span(Span::new(Location::new(2, 2), Location::new(2, 2)), "b"); assert!(a < b); std::mem::swap(&mut a.span, &mut b.span); assert!(a < b); } } apache-datafusion-sqlparser-rs-0.62.0/src/ast/operator.rs000066400000000000000000000421411517524037000233740ustar00rootroot00000000000000// 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::fmt; #[cfg(not(feature = "std"))] use alloc::{string::String, vec::Vec}; #[cfg(feature = "serde")] use serde::{Deserialize, Serialize}; #[cfg(feature = "visitor")] use sqlparser_derive::{Visit, VisitMut}; use super::display_separated; /// Unary operators #[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 UnaryOperator { /// `@-@` Length or circumference (PostgreSQL/Redshift geometric operator) /// see AtDashAt, /// Unary logical not operator: e.g. `! false` (Hive-specific) BangNot, /// Bitwise Not, e.g. `~9` BitwiseNot, /// `@@` Center (PostgreSQL/Redshift geometric operator) /// see DoubleAt, /// `#` Number of points in path or polygon (PostgreSQL/Redshift geometric operator) /// see Hash, /// Plus, e.g. `+9` Plus, /// Minus, e.g. `-9` Minus, /// Not, e.g. `NOT(true)` Not, /// Absolute value, e.g. `@ -9` (PostgreSQL-specific) PGAbs, /// Cube root, e.g. `||/27` (PostgreSQL-specific) PGCubeRoot, /// Factorial, e.g. `9!` (PostgreSQL-specific) PGPostfixFactorial, /// Factorial, e.g. `!!9` (PostgreSQL-specific) PGPrefixFactorial, /// Square root, e.g. `|/9` (PostgreSQL-specific) PGSquareRoot, /// `?-` Is horizontal? (PostgreSQL/Redshift geometric operator) /// see QuestionDash, /// `?|` Is vertical? (PostgreSQL/Redshift geometric operator) /// see QuestionPipe, } impl fmt::Display for UnaryOperator { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str(match self { UnaryOperator::AtDashAt => "@-@", UnaryOperator::BangNot => "!", UnaryOperator::BitwiseNot => "~", UnaryOperator::DoubleAt => "@@", UnaryOperator::Hash => "#", UnaryOperator::Minus => "-", UnaryOperator::Not => "NOT", UnaryOperator::PGAbs => "@", UnaryOperator::PGCubeRoot => "||/", UnaryOperator::PGPostfixFactorial => "!", UnaryOperator::PGPrefixFactorial => "!!", UnaryOperator::PGSquareRoot => "|/", UnaryOperator::Plus => "+", UnaryOperator::QuestionDash => "?-", UnaryOperator::QuestionPipe => "?|", }) } } /// Binary operators #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum BinaryOperator { /// Plus, e.g. `a + b` Plus, /// Minus, e.g. `a - b` Minus, /// Multiply, e.g. `a * b` Multiply, /// Divide, e.g. `a / b` Divide, /// Modulo, e.g. `a % b` Modulo, /// String/Array Concat operator, e.g. `a || b` StringConcat, /// Greater than, e.g. `a > b` Gt, /// Less than, e.g. `a < b` Lt, /// Greater equal, e.g. `a >= b` GtEq, /// Less equal, e.g. `a <= b` LtEq, /// Spaceship, e.g. `a <=> b` Spaceship, /// Equal, e.g. `a = b` Eq, /// Not equal, e.g. `a <> b` NotEq, /// And, e.g. `a AND b` And, /// Or, e.g. `a OR b` Or, /// XOR, e.g. `a XOR b` Xor, /// Bitwise or, e.g. `a | b` BitwiseOr, /// Bitwise and, e.g. `a & b` BitwiseAnd, /// Bitwise XOR, e.g. `a ^ b` BitwiseXor, /// Integer division operator `//` in DuckDB 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 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) PGBitwiseXor, /// Bitwise shift left, e.g. `a << b` (PostgreSQL-specific) PGBitwiseShiftLeft, /// Bitwise shift right, e.g. `a >> b` (PostgreSQL-specific) PGBitwiseShiftRight, /// Exponent, e.g. `a ^ b` (PostgreSQL-specific) PGExp, /// Overlap operator, e.g. `a && b` (PostgreSQL-specific) PGOverlap, /// String matches regular expression (case sensitively), e.g. `a ~ b` (PostgreSQL-specific) PGRegexMatch, /// String matches regular expression (case insensitively), e.g. `a ~* b` (PostgreSQL-specific) PGRegexIMatch, /// String does not match regular expression (case sensitively), e.g. `a !~ b` (PostgreSQL-specific) PGRegexNotMatch, /// String does not match regular expression (case insensitively), e.g. `a !~* b` (PostgreSQL-specific) PGRegexNotIMatch, /// String matches pattern (case sensitively), e.g. `a ~~ b` (PostgreSQL-specific) PGLikeMatch, /// String matches pattern (case insensitively), e.g. `a ~~* b` (PostgreSQL-specific) PGILikeMatch, /// String does not match pattern (case sensitively), e.g. `a !~~ b` (PostgreSQL-specific) PGNotLikeMatch, /// String does not match pattern (case insensitively), e.g. `a !~~* b` (PostgreSQL-specific) PGNotILikeMatch, /// String "starts with", eg: `a ^@ b` (PostgreSQL-specific) PGStartsWith, /// The `->` operator. /// /// On PostgreSQL, this operator extracts a JSON object field or array /// element, for example `'{"a":"b"}'::json -> 'a'` or `[1, 2, 3]'::json /// -> 2`. /// /// See . Arrow, /// The `->>` operator. /// /// On PostgreSQL, this operator extracts a JSON object field or JSON /// array element and converts it to text, for example `'{"a":"b"}'::json /// ->> 'a'` or `[1, 2, 3]'::json ->> 2`. /// /// See . LongArrow, /// The `#>` operator. /// /// On PostgreSQL, this operator extracts a JSON sub-object at the specified /// path, for example: /// /// ```notrust ///'{"a": {"b": ["foo","bar"]}}'::json #> '{a,b,1}' /// ``` /// /// See . HashArrow, /// The `#>>` operator. /// /// A PostgreSQL-specific operator that extracts JSON sub-object at the /// specified path, for example /// /// ```notrust ///'{"a": {"b": ["foo","bar"]}}'::json #>> '{a,b,1}' /// ``` /// /// See . HashLongArrow, /// The `@@` operator. /// /// On PostgreSQL, this is used for JSON and text searches. /// /// See . /// See . AtAt, /// The `@>` operator. /// /// On PostgreSQL, this is used for JSON and text searches. /// /// See . /// See . AtArrow, /// The `<@` operator. /// /// On PostgreSQL, this is used for JSON and text searches. /// /// See . /// See . ArrowAt, /// The `#-` operator. /// /// On PostgreSQL, this operator is used to delete a field or array element /// at a specified path. /// /// See . HashMinus, /// The `@?` operator. /// /// On PostgreSQL, this operator is used to check the given JSON path /// returns an item for the JSON value. /// /// See . AtQuestion, /// The `?` operator. /// /// On PostgreSQL, this operator is used to check whether a string exists as a top-level key /// within the JSON value /// /// See . Question, /// The `?&` operator. /// /// On PostgreSQL, this operator is used to check whether all of the the indicated array /// members exist as top-level keys. /// /// See . QuestionAnd, /// The `?|` operator. /// /// On PostgreSQL, this operator is used to check whether any of the the indicated array /// members exist as top-level keys. /// /// See . QuestionPipe, /// PostgreSQL-specific custom operator. /// /// See [CREATE OPERATOR](https://www.postgresql.org/docs/current/sql-createoperator.html) /// for more information. PGCustomBinaryOperator(Vec), /// The `OVERLAPS` operator /// /// Specifies a test for an overlap between two datetime periods: /// Overlaps, /// `##` Point of closest proximity (PostgreSQL/Redshift geometric operator) /// See DoubleHash, /// `<->` Distance between (PostgreSQL/Redshift geometric operator) /// See LtDashGt, /// `&<` Overlaps to left? (PostgreSQL/Redshift geometric operator) /// See AndLt, /// `&>` Overlaps to right? (PostgreSQL/Redshift geometric operator) /// See AndGt, /// `<<|` Is strictly below? (PostgreSQL/Redshift geometric operator) /// See LtLtPipe, /// `|>>` Is strictly above? (PostgreSQL/Redshift geometric operator) /// See PipeGtGt, /// `&<|` Does not extend above? (PostgreSQL/Redshift geometric operator) /// See AndLtPipe, /// `|&>` Does not extend below? (PostgreSQL/Redshift geometric operator) /// See PipeAndGt, /// `<^` Is below? (PostgreSQL/Redshift geometric operator) /// See LtCaret, /// `>^` Is above? (PostgreSQL/Redshift geometric operator) /// See GtCaret, /// `?#` Intersects? (PostgreSQL/Redshift geometric operator) /// See QuestionHash, /// `?-` Is horizontal? (PostgreSQL/Redshift geometric operator) /// See QuestionDash, /// `?-|` Is perpendicular? (PostgreSQL/Redshift geometric operator) /// See QuestionDashPipe, /// `?||` Are Parallel? (PostgreSQL/Redshift geometric operator) /// See QuestionDoublePipe, /// `@` Contained or on? (PostgreSQL/Redshift geometric operator) /// See At, /// `~=` Same as? (PostgreSQL/Redshift geometric operator) /// See TildeEq, /// ':=' Assignment Operator /// See Assignment, } impl fmt::Display for BinaryOperator { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { BinaryOperator::Plus => f.write_str("+"), BinaryOperator::Minus => f.write_str("-"), BinaryOperator::Multiply => f.write_str("*"), BinaryOperator::Divide => f.write_str("/"), BinaryOperator::Modulo => f.write_str("%"), BinaryOperator::StringConcat => f.write_str("||"), BinaryOperator::Gt => f.write_str(">"), BinaryOperator::Lt => f.write_str("<"), BinaryOperator::GtEq => f.write_str(">="), BinaryOperator::LtEq => f.write_str("<="), BinaryOperator::Spaceship => f.write_str("<=>"), BinaryOperator::Eq => f.write_str("="), BinaryOperator::NotEq => f.write_str("<>"), BinaryOperator::And => f.write_str("AND"), BinaryOperator::Or => f.write_str("OR"), BinaryOperator::Xor => f.write_str("XOR"), BinaryOperator::BitwiseOr => f.write_str("|"), BinaryOperator::BitwiseAnd => f.write_str("&"), 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("<<"), BinaryOperator::PGBitwiseShiftRight => f.write_str(">>"), BinaryOperator::PGExp => f.write_str("^"), BinaryOperator::PGOverlap => f.write_str("&&"), BinaryOperator::PGRegexMatch => f.write_str("~"), BinaryOperator::PGRegexIMatch => f.write_str("~*"), BinaryOperator::PGRegexNotMatch => f.write_str("!~"), BinaryOperator::PGRegexNotIMatch => f.write_str("!~*"), BinaryOperator::PGLikeMatch => f.write_str("~~"), BinaryOperator::PGILikeMatch => f.write_str("~~*"), BinaryOperator::PGNotLikeMatch => f.write_str("!~~"), BinaryOperator::PGNotILikeMatch => f.write_str("!~~*"), BinaryOperator::PGStartsWith => f.write_str("^@"), BinaryOperator::Arrow => f.write_str("->"), BinaryOperator::LongArrow => f.write_str("->>"), BinaryOperator::HashArrow => f.write_str("#>"), BinaryOperator::HashLongArrow => f.write_str("#>>"), BinaryOperator::AtAt => f.write_str("@@"), BinaryOperator::AtArrow => f.write_str("@>"), BinaryOperator::ArrowAt => f.write_str("<@"), BinaryOperator::HashMinus => f.write_str("#-"), BinaryOperator::AtQuestion => f.write_str("@?"), BinaryOperator::Question => f.write_str("?"), BinaryOperator::QuestionAnd => f.write_str("?&"), BinaryOperator::QuestionPipe => f.write_str("?|"), 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(":="), } } } apache-datafusion-sqlparser-rs-0.62.0/src/ast/query.rs000066400000000000000000004602761517524037000227230ustar00rootroot00000000000000// 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. #[cfg(not(feature = "std"))] use alloc::{boxed::Box, vec::Vec}; use helpers::attached_token::AttachedToken; #[cfg(feature = "serde")] use serde::{Deserialize, Serialize}; #[cfg(feature = "visitor")] use sqlparser_derive::{Visit, VisitMut}; use crate::{ ast::*, display_utils::{indented_list, SpaceOrNewline}, tokenizer::{Token, TokenWithSpan}, }; /// The most complete variant of a `SELECT` query expression, optionally /// including `WITH`, `UNION` / other set operations, and `ORDER BY`. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] #[cfg_attr(feature = "visitor", visit(with = "visit_query"))] pub struct Query { /// WITH (common table expressions, or CTEs) pub with: Option, /// SELECT or UNION / EXCEPT / INTERSECT pub body: Box, /// ORDER BY pub order_by: Option, /// `LIMIT ... OFFSET ... | LIMIT , ` pub limit_clause: Option, /// `FETCH { FIRST | NEXT } [ PERCENT ] { ROW | ROWS } | { ONLY | WITH TIES }` pub fetch: Option, /// `FOR { UPDATE | SHARE } [ OF table_name ] [ SKIP LOCKED | NOWAIT ]` pub locks: Vec, /// `FOR XML { RAW | AUTO | EXPLICIT | PATH } [ , ELEMENTS ]` /// `FOR JSON { AUTO | PATH } [ , INCLUDE_NULL_VALUES ]` /// (MSSQL-specific) pub for_clause: Option, /// ClickHouse syntax: `SELECT * FROM t SETTINGS key1 = value1, key2 = value2` /// /// [ClickHouse](https://clickhouse.com/docs/en/sql-reference/statements/select#settings-in-select-query) pub settings: Option>, /// `SELECT * FROM t FORMAT JSONCompact` /// /// [ClickHouse](https://clickhouse.com/docs/en/sql-reference/statements/select/format) /// (ClickHouse-specific) pub format_clause: Option, /// Pipe operator pub pipe_operators: Vec, } impl fmt::Display for Query { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { if let Some(ref with) = self.with { with.fmt(f)?; SpaceOrNewline.fmt(f)?; } self.body.fmt(f)?; if let Some(ref order_by) = self.order_by { f.write_str(" ")?; order_by.fmt(f)?; } if let Some(ref limit_clause) = self.limit_clause { limit_clause.fmt(f)?; } if let Some(ref settings) = self.settings { f.write_str(" SETTINGS ")?; display_comma_separated(settings).fmt(f)?; } if let Some(ref fetch) = self.fetch { f.write_str(" ")?; fetch.fmt(f)?; } if !self.locks.is_empty() { f.write_str(" ")?; display_separated(&self.locks, " ").fmt(f)?; } if let Some(ref for_clause) = self.for_clause { f.write_str(" ")?; for_clause.fmt(f)?; } if let Some(ref format) = self.format_clause { f.write_str(" ")?; format.fmt(f)?; } for pipe_operator in &self.pipe_operators { f.write_str(" |> ")?; pipe_operator.fmt(f)?; } Ok(()) } } /// Query syntax for ClickHouse ADD PROJECTION statement. /// Its syntax is similar to SELECT statement, but it is used to add a new projection to a table. /// Syntax is `SELECT [GROUP BY] [ORDER BY]` /// /// [ClickHouse](https://clickhouse.com/docs/en/sql-reference/statements/alter/projection#add-projection) #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct ProjectionSelect { /// The list of projected select items. pub projection: Vec, /// Optional `ORDER BY` clause for the projection-select. pub order_by: Option, /// Optional `GROUP BY` clause for the projection-select. pub group_by: Option, } impl fmt::Display for ProjectionSelect { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "SELECT {}", display_comma_separated(&self.projection))?; if let Some(ref group_by) = self.group_by { write!(f, " {group_by}")?; } if let Some(ref order_by) = self.order_by { write!(f, " {order_by}")?; } Ok(()) } } /// A node in a tree, representing a "query body" expression, roughly: /// `SELECT ... [ {UNION|EXCEPT|INTERSECT} SELECT ...]` #[allow(clippy::large_enum_variant)] #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum SetExpr { /// Restricted SELECT .. FROM .. HAVING (no ORDER BY or set operations) Select(Box
), } impl SetExpr { /// If this `SetExpr` is a `SELECT`, returns the [`Select`]. pub fn as_select(&self) -> Option<&Select> { if let Self::Select(select) = self { Some(&**select) } else { None } } } impl fmt::Display for SetExpr { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { SetExpr::Select(s) => s.fmt(f), SetExpr::Query(q) => { f.write_str("(")?; q.fmt(f)?; f.write_str(")") } SetExpr::Values(v) => v.fmt(f), SetExpr::Insert(v) => v.fmt(f), SetExpr::Update(v) => v.fmt(f), SetExpr::Delete(v) => v.fmt(f), SetExpr::Merge(v) => v.fmt(f), SetExpr::Table(t) => t.fmt(f), SetExpr::SetOperation { left, right, op, set_quantifier, } => { left.fmt(f)?; SpaceOrNewline.fmt(f)?; op.fmt(f)?; match set_quantifier { SetQuantifier::All | SetQuantifier::Distinct | SetQuantifier::ByName | SetQuantifier::AllByName | SetQuantifier::DistinctByName => { f.write_str(" ")?; set_quantifier.fmt(f)?; } SetQuantifier::None => {} } SpaceOrNewline.fmt(f)?; right.fmt(f)?; Ok(()) } } } } #[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// A set operator for combining two `SetExpr`s. pub enum SetOperator { /// `UNION` set operator Union, /// `EXCEPT` set operator Except, /// `INTERSECT` set operator Intersect, /// `MINUS` set operator (non-standard) Minus, } impl fmt::Display for SetOperator { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str(match self { SetOperator::Union => "UNION", SetOperator::Except => "EXCEPT", SetOperator::Intersect => "INTERSECT", SetOperator::Minus => "MINUS", }) } } /// A quantifier for [SetOperator]. // TODO: Restrict parsing specific SetQuantifier in some specific dialects. // For example, BigQuery does not support `DISTINCT` for `EXCEPT` and `INTERSECT` #[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 SetQuantifier { /// `ALL` quantifier All, /// `DISTINCT` quantifier Distinct, /// `BY NAME` quantifier ByName, /// `ALL BY NAME` quantifier AllByName, /// `DISTINCT BY NAME` quantifier DistinctByName, /// No quantifier specified None, } impl fmt::Display for SetQuantifier { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { SetQuantifier::All => write!(f, "ALL"), SetQuantifier::Distinct => write!(f, "DISTINCT"), SetQuantifier::ByName => write!(f, "BY NAME"), SetQuantifier::AllByName => write!(f, "ALL BY NAME"), SetQuantifier::DistinctByName => write!(f, "DISTINCT BY NAME"), SetQuantifier::None => Ok(()), } } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] /// A [`TABLE` command]( https://www.postgresql.org/docs/current/sql-select.html#SQL-TABLE) #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// A (possibly schema-qualified) table reference used in `FROM` clauses. pub struct Table { /// Optional table name (absent for e.g. `TABLE` command without argument). pub table_name: Option, /// Optional schema/catalog name qualifying the table. pub schema_name: Option, } impl fmt::Display for Table { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { if let Some(ref schema_name) = self.schema_name { write!( f, "TABLE {}.{}", schema_name, self.table_name.as_ref().unwrap(), )?; } else { write!(f, "TABLE {}", self.table_name.as_ref().unwrap(),)?; } Ok(()) } } /// What did this select look like? #[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum SelectFlavor { /// `SELECT *` Standard, /// `FROM ... SELECT *` FromFirst, /// `FROM *` FromFirstNoSelect, } /// MySQL-specific SELECT modifiers that appear after the SELECT keyword. /// /// These modifiers affect query execution and optimization. They can appear in any order after /// SELECT and before the column list, can be repeated, and can be interleaved with /// DISTINCT/DISTINCTROW/ALL: /// /// ```sql /// SELECT /// [ALL | DISTINCT | DISTINCTROW] /// [HIGH_PRIORITY] /// [STRAIGHT_JOIN] /// [SQL_SMALL_RESULT] [SQL_BIG_RESULT] [SQL_BUFFER_RESULT] /// [SQL_NO_CACHE] [SQL_CALC_FOUND_ROWS] /// select_expr [, select_expr] ... /// ``` /// /// See [MySQL SELECT](https://dev.mysql.com/doc/refman/8.4/en/select.html). #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash, Default)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct SelectModifiers { /// `HIGH_PRIORITY` gives the SELECT higher priority than statements that update a table. /// /// pub high_priority: bool, /// `STRAIGHT_JOIN` forces the optimizer to join tables in the order listed in the FROM clause. /// /// pub straight_join: bool, /// `SQL_SMALL_RESULT` hints that the result set is small, using in-memory temp tables. /// /// pub sql_small_result: bool, /// `SQL_BIG_RESULT` hints that the result set is large, using disk-based temp tables. /// /// pub sql_big_result: bool, /// `SQL_BUFFER_RESULT` forces the result to be put into a temporary table to release locks early. /// /// pub sql_buffer_result: bool, /// `SQL_NO_CACHE` tells MySQL not to cache the query result. (Deprecated in 8.4+.) /// /// pub sql_no_cache: bool, /// `SQL_CALC_FOUND_ROWS` tells MySQL to calculate the total number of rows. (Deprecated in 8.0.17+.) /// /// - [MySQL SELECT modifiers](https://dev.mysql.com/doc/refman/8.4/en/select.html) /// - [`FOUND_ROWS()`](https://dev.mysql.com/doc/refman/8.4/en/information-functions.html#function_found-rows) pub sql_calc_found_rows: bool, } impl fmt::Display for SelectModifiers { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { if self.high_priority { f.write_str(" HIGH_PRIORITY")?; } if self.straight_join { f.write_str(" STRAIGHT_JOIN")?; } if self.sql_small_result { f.write_str(" SQL_SMALL_RESULT")?; } if self.sql_big_result { f.write_str(" SQL_BIG_RESULT")?; } if self.sql_buffer_result { f.write_str(" SQL_BUFFER_RESULT")?; } if self.sql_no_cache { f.write_str(" SQL_NO_CACHE")?; } if self.sql_calc_found_rows { f.write_str(" SQL_CALC_FOUND_ROWS")?; } Ok(()) } } impl SelectModifiers { /// Returns true if any of the modifiers are set. pub fn is_any_set(&self) -> bool { // Using irrefutable destructuring to catch fields added in the future let Self { high_priority, straight_join, sql_small_result, sql_big_result, sql_buffer_result, sql_no_cache, sql_calc_found_rows, } = self; *high_priority || *straight_join || *sql_small_result || *sql_big_result || *sql_buffer_result || *sql_no_cache || *sql_calc_found_rows } } /// A restricted variant of `SELECT` (without CTEs/`ORDER BY`), which may /// appear either as the only body item of a `Query`, or as an operand /// to a set operation like `UNION`. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] #[cfg_attr(feature = "visitor", visit(with = "visit_select"))] pub struct Select { /// Token for the `SELECT` keyword pub select_token: AttachedToken, /// Query optimizer hints /// /// [MySQL](https://dev.mysql.com/doc/refman/8.4/en/optimizer-hints.html) /// [Oracle](https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/Comments.html#GUID-D316D545-89E2-4D54-977F-FC97815CD62E) pub optimizer_hints: Vec, /// `SELECT [DISTINCT] ...` pub distinct: Option, /// MySQL-specific SELECT modifiers. /// /// See [MySQL SELECT](https://dev.mysql.com/doc/refman/8.4/en/select.html). pub select_modifiers: Option, /// MSSQL syntax: `TOP () [ PERCENT ] [ WITH TIES ]` pub top: Option, /// Whether the top was located before `ALL`/`DISTINCT` pub top_before_distinct: bool, /// projection expressions pub projection: Vec, /// Excluded columns from the projection expression which are not specified /// directly after a wildcard. /// /// [Redshift](https://docs.aws.amazon.com/redshift/latest/dg/r_EXCLUDE_list.html) pub exclude: Option, /// INTO pub into: Option, /// FROM pub from: Vec, /// LATERAL VIEWs pub lateral_views: Vec, /// ClickHouse syntax: `PREWHERE a = 1 WHERE b = 2`, /// and it can be used together with WHERE selection. /// /// [ClickHouse](https://clickhouse.com/docs/en/sql-reference/statements/select/prewhere) pub prewhere: Option, /// WHERE pub selection: Option, /// [START WITH ..] CONNECT BY .. pub connect_by: Vec, /// GROUP BY pub group_by: GroupByExpr, /// CLUSTER BY (Hive) pub cluster_by: Vec, /// DISTRIBUTE BY (Hive) pub distribute_by: Vec, /// SORT BY (Hive) pub sort_by: Vec, /// HAVING pub having: Option, /// WINDOW AS pub named_window: Vec, /// QUALIFY (Snowflake) pub qualify: Option, /// The positioning of QUALIFY and WINDOW clauses differ between dialects. /// e.g. BigQuery requires that WINDOW comes after QUALIFY, while DUCKDB accepts /// WINDOW before QUALIFY. /// We accept either positioning and flag the accepted variant. pub window_before_qualify: bool, /// BigQuery syntax: `SELECT AS VALUE | SELECT AS STRUCT` pub value_table_mode: Option, /// Was this a FROM-first query? pub flavor: SelectFlavor, } impl fmt::Display for Select { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self.flavor { SelectFlavor::Standard => { write!(f, "SELECT")?; } SelectFlavor::FromFirst => { write!(f, "FROM {} SELECT", display_comma_separated(&self.from))?; } SelectFlavor::FromFirstNoSelect => { write!(f, "FROM {}", display_comma_separated(&self.from))?; } } for hint in &self.optimizer_hints { f.write_str(" ")?; hint.fmt(f)?; } if let Some(value_table_mode) = self.value_table_mode { f.write_str(" ")?; value_table_mode.fmt(f)?; } if let Some(ref top) = self.top { if self.top_before_distinct { f.write_str(" ")?; top.fmt(f)?; } } if let Some(ref distinct) = self.distinct { f.write_str(" ")?; distinct.fmt(f)?; } if let Some(ref top) = self.top { if !self.top_before_distinct { f.write_str(" ")?; top.fmt(f)?; } } if let Some(ref select_modifiers) = self.select_modifiers { select_modifiers.fmt(f)?; } if !self.projection.is_empty() { indented_list(f, &self.projection)?; } if let Some(exclude) = &self.exclude { write!(f, " {exclude}")?; } if let Some(ref into) = self.into { f.write_str(" ")?; into.fmt(f)?; } if self.flavor == SelectFlavor::Standard && !self.from.is_empty() { SpaceOrNewline.fmt(f)?; f.write_str("FROM")?; indented_list(f, &self.from)?; } if !self.lateral_views.is_empty() { for lv in &self.lateral_views { lv.fmt(f)?; } } if let Some(ref prewhere) = self.prewhere { f.write_str(" PREWHERE ")?; prewhere.fmt(f)?; } if let Some(ref selection) = self.selection { SpaceOrNewline.fmt(f)?; f.write_str("WHERE")?; SpaceOrNewline.fmt(f)?; Indent(selection).fmt(f)?; } for clause in &self.connect_by { SpaceOrNewline.fmt(f)?; clause.fmt(f)?; } match &self.group_by { GroupByExpr::All(_) => { SpaceOrNewline.fmt(f)?; self.group_by.fmt(f)?; } GroupByExpr::Expressions(exprs, _) => { if !exprs.is_empty() { SpaceOrNewline.fmt(f)?; self.group_by.fmt(f)?; } } } if !self.cluster_by.is_empty() { SpaceOrNewline.fmt(f)?; f.write_str("CLUSTER BY")?; SpaceOrNewline.fmt(f)?; Indent(display_comma_separated(&self.cluster_by)).fmt(f)?; } if !self.distribute_by.is_empty() { SpaceOrNewline.fmt(f)?; f.write_str("DISTRIBUTE BY")?; SpaceOrNewline.fmt(f)?; display_comma_separated(&self.distribute_by).fmt(f)?; } if !self.sort_by.is_empty() { SpaceOrNewline.fmt(f)?; f.write_str("SORT BY")?; SpaceOrNewline.fmt(f)?; Indent(display_comma_separated(&self.sort_by)).fmt(f)?; } if let Some(ref having) = self.having { SpaceOrNewline.fmt(f)?; f.write_str("HAVING")?; SpaceOrNewline.fmt(f)?; Indent(having).fmt(f)?; } if self.window_before_qualify { if !self.named_window.is_empty() { SpaceOrNewline.fmt(f)?; f.write_str("WINDOW")?; SpaceOrNewline.fmt(f)?; display_comma_separated(&self.named_window).fmt(f)?; } if let Some(ref qualify) = self.qualify { SpaceOrNewline.fmt(f)?; f.write_str("QUALIFY")?; SpaceOrNewline.fmt(f)?; qualify.fmt(f)?; } } else { if let Some(ref qualify) = self.qualify { SpaceOrNewline.fmt(f)?; f.write_str("QUALIFY")?; SpaceOrNewline.fmt(f)?; qualify.fmt(f)?; } if !self.named_window.is_empty() { SpaceOrNewline.fmt(f)?; f.write_str("WINDOW")?; SpaceOrNewline.fmt(f)?; display_comma_separated(&self.named_window).fmt(f)?; } } Ok(()) } } /// A hive LATERAL VIEW with potential column aliases #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct LateralView { /// LATERAL VIEW pub lateral_view: Expr, /// LATERAL VIEW table name pub lateral_view_name: ObjectName, /// LATERAL VIEW optional column aliases pub lateral_col_alias: Vec, /// LATERAL VIEW OUTER pub outer: bool, } impl fmt::Display for LateralView { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, " LATERAL VIEW{outer} {} {}", self.lateral_view, self.lateral_view_name, outer = if self.outer { " OUTER" } else { "" } )?; if !self.lateral_col_alias.is_empty() { write!( f, " AS {}", display_comma_separated(&self.lateral_col_alias) )?; } Ok(()) } } /// An expression used in a named window declaration. /// /// ```sql /// WINDOW mywindow AS [named_window_expr] /// ``` #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum NamedWindowExpr { /// A direct reference to another named window definition. /// [BigQuery] /// /// Example: /// ```sql /// WINDOW mywindow AS prev_window /// ``` /// /// [BigQuery]: https://cloud.google.com/bigquery/docs/reference/standard-sql/window-function-calls#ref_named_window NamedWindow(Ident), /// A window expression. /// /// Example: /// ```sql /// WINDOW mywindow AS (ORDER BY 1) /// ``` WindowSpec(WindowSpec), } impl fmt::Display for NamedWindowExpr { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { NamedWindowExpr::NamedWindow(named_window) => { write!(f, "{named_window}")?; } NamedWindowExpr::WindowSpec(window_spec) => { write!(f, "({window_spec})")?; } }; Ok(()) } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// A named window definition: ` AS ` pub struct NamedWindowDefinition(pub Ident, pub NamedWindowExpr); impl fmt::Display for NamedWindowDefinition { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{} AS {}", self.0, self.1) } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// A `WITH` clause, introducing common table expressions (CTEs). pub struct With { /// Token for the `WITH` keyword pub with_token: AttachedToken, /// Whether the `WITH` is recursive (`WITH RECURSIVE`). pub recursive: bool, /// The list of CTEs declared by this `WITH` clause. pub cte_tables: Vec, } impl fmt::Display for With { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str("WITH ")?; if self.recursive { f.write_str("RECURSIVE ")?; } display_comma_separated(&self.cte_tables).fmt(f)?; Ok(()) } } #[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Indicates whether a CTE is materialized or not. pub enum CteAsMaterialized { /// The `WITH` statement specifies `AS MATERIALIZED` behavior Materialized, /// The `WITH` statement specifies `AS NOT MATERIALIZED` behavior NotMaterialized, } impl fmt::Display for CteAsMaterialized { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { CteAsMaterialized::Materialized => { write!(f, "MATERIALIZED")?; } CteAsMaterialized::NotMaterialized => { write!(f, "NOT MATERIALIZED")?; } }; Ok(()) } } /// A single CTE (used after `WITH`): ` [(col1, col2, ...)] AS ( )` /// The names in the column list before `AS`, when specified, replace the names /// of the columns returned by the query. The parser does not validate that the /// number of columns in the query matches the number of columns in the query. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct Cte { /// The CTE alias (name introduced before the `AS` keyword). pub alias: TableAlias, /// The query that defines the CTE body. pub query: Box, /// Optional `FROM` identifier for materialized CTEs. pub from: Option, /// Optional `AS MATERIALIZED` / `AS NOT MATERIALIZED` hint. pub materialized: Option, /// Token for the closing parenthesis of the CTE definition. pub closing_paren_token: AttachedToken, } impl fmt::Display for Cte { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self.materialized.as_ref() { None => { self.alias.fmt(f)?; f.write_str(" AS (")?; NewLine.fmt(f)?; Indent(&self.query).fmt(f)?; NewLine.fmt(f)?; f.write_str(")")?; } Some(materialized) => { self.alias.fmt(f)?; f.write_str(" AS ")?; materialized.fmt(f)?; f.write_str(" (")?; NewLine.fmt(f)?; Indent(&self.query).fmt(f)?; NewLine.fmt(f)?; f.write_str(")")?; } }; if let Some(ref fr) = self.from { write!(f, " FROM {fr}")?; } Ok(()) } } /// Represents an expression behind a wildcard expansion in a projection. /// `SELECT T.* FROM T; #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum SelectItemQualifiedWildcardKind { /// Expression is an object name. /// e.g. `alias.*` or even `schema.table.*` ObjectName(ObjectName), /// Select star on an arbitrary expression. /// e.g. `STRUCT('foo').*` Expr(Expr), } /// One item of the comma-separated list following `SELECT` #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum SelectItem { /// Any expression, not followed by `[ AS ] alias` UnnamedExpr(Expr), /// An expression, followed by `[ AS ] alias` ExprWithAlias { /// The expression being projected. expr: Expr, /// The alias for the expression. alias: Ident, }, /// An expression, followed by `[ AS ] (alias1, alias2, ...)` /// /// [Spark SQL](https://spark.apache.org/docs/latest/sql-ref-syntax-qry-select.html) ExprWithAliases { /// The expression being projected. expr: Expr, /// The list of aliases for the expression. aliases: Vec, }, /// An expression, followed by a wildcard expansion. /// e.g. `alias.*`, `STRUCT('foo').*` QualifiedWildcard(SelectItemQualifiedWildcardKind, WildcardAdditionalOptions), /// An unqualified `*` Wildcard(WildcardAdditionalOptions), } impl fmt::Display for SelectItemQualifiedWildcardKind { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match &self { SelectItemQualifiedWildcardKind::ObjectName(object_name) => { write!(f, "{object_name}.*") } SelectItemQualifiedWildcardKind::Expr(expr) => write!(f, "{expr}.*"), } } } /// Single aliased identifier /// /// # Syntax /// ```plaintext /// AS /// ``` #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct IdentWithAlias { /// The identifier being aliased. pub ident: Ident, /// The alias to apply to `ident`. pub alias: Ident, } impl fmt::Display for IdentWithAlias { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{} AS {}", self.ident, self.alias) } } /// Additional options for wildcards, e.g. Snowflake `EXCLUDE`/`RENAME` and Bigquery `EXCEPT`. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct WildcardAdditionalOptions { /// The wildcard token `*` pub wildcard_token: AttachedToken, /// `[ILIKE...]`. /// Snowflake syntax: pub opt_ilike: Option, /// `[EXCLUDE...]`. pub opt_exclude: Option, /// `[EXCEPT...]`. /// Clickhouse syntax: pub opt_except: Option, /// `[REPLACE]` /// BigQuery syntax: /// Clickhouse syntax: /// Snowflake syntax: pub opt_replace: Option, /// `[RENAME ...]`. pub opt_rename: Option, /// `[AS ]`. /// Redshift syntax: pub opt_alias: Option, } impl Default for WildcardAdditionalOptions { fn default() -> Self { Self { wildcard_token: TokenWithSpan::wrap(Token::Mul).into(), opt_ilike: None, opt_exclude: None, opt_except: None, opt_replace: None, opt_rename: None, opt_alias: None, } } } impl fmt::Display for WildcardAdditionalOptions { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { if let Some(ilike) = &self.opt_ilike { write!(f, " {ilike}")?; } if let Some(exclude) = &self.opt_exclude { write!(f, " {exclude}")?; } if let Some(except) = &self.opt_except { write!(f, " {except}")?; } if let Some(replace) = &self.opt_replace { write!(f, " {replace}")?; } if let Some(rename) = &self.opt_rename { write!(f, " {rename}")?; } if let Some(alias) = &self.opt_alias { write!(f, " AS {alias}")?; } Ok(()) } } /// Snowflake `ILIKE` information. /// /// # Syntax /// ```plaintext /// ILIKE /// ``` #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct IlikeSelectItem { /// The pattern expression used with `ILIKE`. pub pattern: String, } impl fmt::Display for IlikeSelectItem { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "ILIKE '{}'", value::escape_single_quote_string(&self.pattern) )?; Ok(()) } } /// Snowflake `EXCLUDE` information. /// /// # Syntax /// ```plaintext /// /// | (, , ...) /// ``` #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum ExcludeSelectItem { /// Single column name without parenthesis. /// /// # Syntax /// ```plaintext /// /// ``` Single(ObjectName), /// Multiple column names inside parenthesis. /// # Syntax /// ```plaintext /// (, , ...) /// ``` Multiple(Vec), } impl fmt::Display for ExcludeSelectItem { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "EXCLUDE")?; match self { Self::Single(column) => { write!(f, " {column}")?; } Self::Multiple(columns) => { write!(f, " ({})", display_comma_separated(columns))?; } } Ok(()) } } /// Snowflake `RENAME` information. /// /// # Syntax /// ```plaintext /// AS /// | ( AS , AS , ...) /// ``` #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum RenameSelectItem { /// Single column name with alias without parenthesis. /// /// # Syntax /// ```plaintext /// AS /// ``` Single(IdentWithAlias), /// Multiple column names with aliases inside parenthesis. /// # Syntax /// ```plaintext /// ( AS , AS , ...) /// ``` Multiple(Vec), } impl fmt::Display for RenameSelectItem { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "RENAME")?; match self { Self::Single(column) => { write!(f, " {column}")?; } Self::Multiple(columns) => { write!(f, " ({})", display_comma_separated(columns))?; } } Ok(()) } } /// Bigquery `EXCEPT` information, with at least one column. /// /// # Syntax /// ```plaintext /// EXCEPT ( [, ...]) /// ``` #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct ExceptSelectItem { /// First guaranteed column. pub first_element: Ident, /// Additional columns. This list can be empty. pub additional_elements: Vec, } impl fmt::Display for ExceptSelectItem { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "EXCEPT ")?; if self.additional_elements.is_empty() { write!(f, "({})", self.first_element)?; } else { write!( f, "({}, {})", self.first_element, display_comma_separated(&self.additional_elements) )?; } Ok(()) } } /// Bigquery `REPLACE` information. /// /// # Syntax /// ```plaintext /// REPLACE ( [AS] ) /// REPLACE ( [AS] , [AS] , ...) /// ``` #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct ReplaceSelectItem { /// List of replacement elements contained in the `REPLACE(...)` clause. pub items: Vec>, } impl fmt::Display for ReplaceSelectItem { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "REPLACE")?; write!(f, " ({})", display_comma_separated(&self.items))?; Ok(()) } } /// # Syntax /// ```plaintext /// [AS] /// ``` #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct ReplaceSelectElement { /// Expression producing the replacement value. pub expr: Expr, /// The target column name for the replacement. pub column_name: Ident, /// Whether the `AS` keyword was present in the original syntax. pub as_keyword: bool, } impl fmt::Display for ReplaceSelectElement { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { if self.as_keyword { write!(f, "{} AS {}", self.expr, self.column_name) } else { write!(f, "{} {}", self.expr, self.column_name) } } } impl fmt::Display for SelectItem { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { use core::fmt::Write; match &self { SelectItem::UnnamedExpr(expr) => expr.fmt(f), SelectItem::ExprWithAlias { expr, alias } => { expr.fmt(f)?; f.write_str(" AS ")?; alias.fmt(f) } SelectItem::ExprWithAliases { expr, aliases } => { expr.fmt(f)?; f.write_str(" AS (")?; display_comma_separated(aliases).fmt(f)?; f.write_str(")") } SelectItem::QualifiedWildcard(kind, additional_options) => { kind.fmt(f)?; additional_options.fmt(f) } SelectItem::Wildcard(additional_options) => { f.write_char('*')?; additional_options.fmt(f) } } } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// A left table followed by zero or more joins. pub struct TableWithJoins { /// The starting table factor (left side) of the join chain. pub relation: TableFactor, /// The sequence of joins applied to the relation. pub joins: Vec, } impl fmt::Display for TableWithJoins { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { self.relation.fmt(f)?; for join in &self.joins { SpaceOrNewline.fmt(f)?; join.fmt(f)?; } Ok(()) } } /// Joins a table to itself to process hierarchical data in the table. /// /// See . /// See #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum ConnectByKind { /// CONNECT BY ConnectBy { /// the `CONNECT` token connect_token: AttachedToken, /// [CONNECT BY] NOCYCLE /// /// Optional on [Oracle](https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/Hierarchical-Queries.html#GUID-0118DF1D-B9A9-41EB-8556-C6E7D6A5A84E__GUID-5377971A-F518-47E4-8781-F06FEB3EF993) nocycle: bool, /// join conditions denoting the hierarchical relationship relationships: Vec, }, /// START WITH /// /// Optional on [Oracle](https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/Hierarchical-Queries.html#GUID-0118DF1D-B9A9-41EB-8556-C6E7D6A5A84E) /// when comming _after_ the `CONNECT BY`. StartWith { /// the `START` token start_token: AttachedToken, /// condition selecting the root rows of the hierarchy condition: Box, }, } impl fmt::Display for ConnectByKind { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { ConnectByKind::ConnectBy { connect_token: _, nocycle, relationships, } => { write!( f, "CONNECT BY {nocycle}{relationships}", nocycle = if *nocycle { "NOCYCLE " } else { "" }, relationships = display_comma_separated(relationships) ) } ConnectByKind::StartWith { start_token: _, condition, } => { write!(f, "START WITH {condition}") } } } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// A single setting key-value pair. pub struct Setting { /// Setting name/key. pub key: Ident, /// The value expression assigned to the setting. pub value: Expr, } impl fmt::Display for Setting { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{} = {}", self.key, self.value) } } /// An expression optionally followed by an alias. /// /// Example: /// ```sql /// 42 AS myint /// ``` #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct ExprWithAlias { /// The expression. pub expr: Expr, /// Optional alias for the expression. pub alias: Option, } impl fmt::Display for ExprWithAlias { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let ExprWithAlias { expr, alias } = self; write!(f, "{expr}")?; if let Some(alias) = alias { write!(f, " AS {alias}")?; } Ok(()) } } /// An expression optionally followed by an alias and order by options. /// /// Example: /// ```sql /// 42 AS myint ASC /// ``` #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct ExprWithAliasAndOrderBy { /// Expression with optional alias. pub expr: ExprWithAlias, /// Ordering options applied to the expression. pub order_by: OrderByOptions, } impl fmt::Display for ExprWithAliasAndOrderBy { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{}{}", self.expr, self.order_by) } } /// Arguments to a table-valued function #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct TableFunctionArgs { /// The list of arguments passed to the table-valued function. pub args: Vec, /// ClickHouse-specific `SETTINGS` clause. /// For example, /// `SELECT * FROM executable('generate_random.py', TabSeparated, 'id UInt32, random String', SETTINGS send_chunk_header = false, pool_size = 16)` /// [`executable` table function](https://clickhouse.com/docs/en/engines/table-functions/executable) pub settings: Option>, } #[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Type of index hint (e.g., `USE`, `IGNORE`, `FORCE`). pub enum TableIndexHintType { /// `USE` hint. Use, /// `IGNORE` hint. Ignore, /// `FORCE` hint. Force, } impl fmt::Display for TableIndexHintType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str(match self { TableIndexHintType::Use => "USE", TableIndexHintType::Ignore => "IGNORE", TableIndexHintType::Force => "FORCE", }) } } #[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// The kind of index referenced by an index hint (e.g. `USE INDEX`). pub enum TableIndexType { /// The `INDEX` kind. Index, /// The `KEY` kind. Key, } impl fmt::Display for TableIndexType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str(match self { TableIndexType::Index => "INDEX", TableIndexType::Key => "KEY", }) } } #[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Which clause the table index hint applies to. pub enum TableIndexHintForClause { /// Apply the hint to JOIN clauses. Join, /// Apply the hint to `ORDER BY` clauses. OrderBy, /// Apply the hint to `GROUP BY` clauses. GroupBy, } impl fmt::Display for TableIndexHintForClause { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str(match self { TableIndexHintForClause::Join => "JOIN", TableIndexHintForClause::OrderBy => "ORDER BY", TableIndexHintForClause::GroupBy => "GROUP BY", }) } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// MySQL-style index hints attached to a table (e.g., `USE INDEX(...)`). pub struct TableIndexHints { /// Type of hint (e.g., `USE`, `FORCE`, or `IGNORE`). pub hint_type: TableIndexHintType, /// The index type (e.g., `INDEX`). pub index_type: TableIndexType, /// Optional `FOR` clause specifying the scope (JOIN / ORDER BY / GROUP BY). pub for_clause: Option, /// List of index names referred to by the hint. pub index_names: Vec, } impl fmt::Display for TableIndexHints { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{} {} ", self.hint_type, self.index_type)?; if let Some(for_clause) = &self.for_clause { write!(f, "FOR {for_clause} ")?; } write!(f, "({})", display_comma_separated(&self.index_names)) } } /// A table name or a parenthesized subquery with an optional alias #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] #[cfg_attr(feature = "visitor", visit(with = "visit_table_factor"))] pub enum TableFactor { /// A named table or relation, possibly with arguments, hints, or sampling. Table { #[cfg_attr(feature = "visitor", visit(with = "visit_relation"))] /// Table or relation name. name: ObjectName, /// Optional alias for the table (e.g. `table AS t`). alias: Option, /// Arguments of a table-valued function, as supported by Postgres /// and MSSQL. Note that deprecated MSSQL `FROM foo (NOLOCK)` syntax /// will also be parsed as `args`. /// /// This field's value is `Some(v)`, where `v` is a (possibly empty) /// vector of arguments, in the case of a table-valued function call, /// whereas it's `None` in the case of a regular table name. args: Option, /// MSSQL-specific `WITH (...)` hints such as NOLOCK. with_hints: Vec, /// Optional version qualifier to facilitate table time-travel, as /// supported by BigQuery and MSSQL. version: Option, // Optional table function modifier to generate the ordinality for column. /// For example, `SELECT * FROM generate_series(1, 10) WITH ORDINALITY AS t(a, b);` /// [WITH ORDINALITY](https://www.postgresql.org/docs/current/functions-srf.html), supported by Postgres. with_ordinality: bool, /// [Partition selection](https://dev.mysql.com/doc/refman/8.0/en/partitioning-selection.html), supported by MySQL. partitions: Vec, /// Optional PartiQL JsonPath: json_path: Option, /// Optional table sample modifier /// See: sample: Option, /// Optional index hints(mysql) /// See: index_hints: Vec, }, /// A derived table (a parenthesized subquery), optionally `LATERAL`. Derived { /// Whether the derived table is LATERAL. lateral: bool, /// The subquery producing the derived table. subquery: Box, /// Optional alias for the derived table. alias: Option, /// Optional table sample modifier sample: Option, }, /// `TABLE()[ AS ]` TableFunction { /// Expression representing the table function call. expr: Expr, /// Optional alias for the table function result. alias: Option, }, /// `e.g. LATERAL FLATTEN()[ AS ]` Function { /// Whether the function is LATERAL. lateral: bool, /// Name of the table function. name: ObjectName, /// Arguments passed to the function. args: Vec, /// Whether `WITH ORDINALITY` was specified to include ordinality. with_ordinality: bool, /// Optional alias for the result of the function. alias: Option, }, /// ```sql /// SELECT * FROM UNNEST ([10,20,30]) as numbers WITH OFFSET; /// +---------+--------+ /// | numbers | offset | /// +---------+--------+ /// | 10 | 0 | /// | 20 | 1 | /// | 30 | 2 | /// +---------+--------+ /// ``` UNNEST { /// Optional alias for the UNNEST table (e.g. `UNNEST(...) AS t`). alias: Option, /// Expressions producing the arrays to be unnested. array_exprs: Vec, /// Whether `WITH OFFSET` was specified to include element offsets. with_offset: bool, /// Optional alias for the offset column when `WITH OFFSET` is used. with_offset_alias: Option, /// Whether `WITH ORDINALITY` was specified to include ordinality. with_ordinality: bool, }, /// The `JSON_TABLE` table-valued function. /// Part of the SQL standard, but implemented only by MySQL, Oracle, and DB2. /// /// /// /// /// ```sql /// SELECT * FROM JSON_TABLE( /// '[{"a": 1, "b": 2}, {"a": 3, "b": 4}]', /// '$[*]' COLUMNS( /// a INT PATH '$.a' DEFAULT '0' ON EMPTY, /// b INT PATH '$.b' NULL ON ERROR /// ) /// ) AS jt; /// ```` JsonTable { /// The JSON expression to be evaluated. It must evaluate to a json string json_expr: Expr, /// The path to the array or object to be iterated over. /// It must evaluate to a json array or object. json_path: ValueWithSpan, /// The columns to be extracted from each element of the array or object. /// Each column must have a name and a type. columns: Vec, /// The alias for the table. alias: Option, }, /// The MSSQL's `OPENJSON` table-valued function. /// /// ```sql /// OPENJSON( jsonExpression [ , path ] ) [ ] /// /// ::= WITH ( { colName type [ column_path ] [ AS JSON ] } [ ,...n ] ) /// ```` /// /// Reference: OpenJsonTable { /// The JSON expression to be evaluated. It must evaluate to a json string json_expr: Expr, /// The path to the array or object to be iterated over. /// It must evaluate to a json array or object. json_path: Option, /// The columns to be extracted from each element of the array or object. /// Each column must have a name and a type. columns: Vec, /// The alias for the table. alias: Option, }, /// Represents a parenthesized table factor. The SQL spec only allows a /// join expression (`(foo bar [ baz ... ])`) to be nested, /// possibly several times. /// /// The parser may also accept non-standard nesting of bare tables for some /// dialects, but the information about such nesting is stripped from AST. NestedJoin { /// The nested join expression contained in parentheses. table_with_joins: Box, /// Optional alias for the nested join. alias: Option, }, /// Represents PIVOT operation on a table. /// For example `FROM monthly_sales PIVOT(sum(amount) FOR MONTH IN ('JAN', 'FEB'))` /// /// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/query-syntax#pivot_operator) /// [Snowflake](https://docs.snowflake.com/en/sql-reference/constructs/pivot) /// [Oracle](https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/SELECT.html#GUID-CFA006CA-6FF1-4972-821E-6996142A51C6__GUID-68257B27-1C4C-4C47-8140-5C60E0E65D35) Pivot { /// The input table to pivot. table: Box, /// Aggregate expressions used as pivot values (optionally aliased). aggregate_functions: Vec, // Function expression /// Columns producing the values to be pivoted. value_column: Vec, /// Source of pivot values (e.g. list of literals or columns). value_source: PivotValueSource, /// Optional expression providing a default when a pivot produces NULL. default_on_null: Option, /// Optional alias for the pivoted table. alias: Option, }, /// An UNPIVOT operation on a table. /// /// Syntax: /// ```sql /// table UNPIVOT [ { INCLUDE | EXCLUDE } NULLS ] (value FOR name IN (column1, [ column2, ... ])) [ alias ] /// ``` /// /// [Snowflake](https://docs.snowflake.com/en/sql-reference/constructs/unpivot) /// [Databricks](https://docs.databricks.com/aws/en/sql/language-manual/sql-ref-syntax-qry-select-unpivot) /// [BigQuery](https://docs.cloud.google.com/bigquery/docs/reference/standard-sql/query-syntax#unpivot_operator) /// [Oracle](https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/SELECT.html#GUID-CFA006CA-6FF1-4972-821E-6996142A51C6__GUID-9B4E0389-413C-4014-94A1-0A0571BDF7E1) Unpivot { /// The input table to unpivot. table: Box, /// Expression producing the unpivoted value. value: Expr, /// Identifier used for the generated column name. name: Ident, /// Columns or expressions to unpivot, optionally aliased. columns: Vec, /// Whether to include or exclude NULLs during unpivot. null_inclusion: Option, /// Optional alias for the resulting table. alias: Option, }, /// A `MATCH_RECOGNIZE` operation on a table. /// /// See . MatchRecognize { /// The input table to apply `MATCH_RECOGNIZE` on. table: Box, /// `PARTITION BY [, ... ]` partition_by: Vec, /// `ORDER BY [, ... ]` order_by: Vec, /// `MEASURES [AS] [, ... ]` measures: Vec, /// `ONE ROW PER MATCH | ALL ROWS PER MATCH [
[alias] ON ` or `|> [JOIN_TYPE] JOIN
[alias] USING ()` /// /// See more at Join(Join), } impl fmt::Display for PipeOperator { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { PipeOperator::Select { exprs } => { write!(f, "SELECT {}", display_comma_separated(exprs.as_slice())) } PipeOperator::Extend { exprs } => { write!(f, "EXTEND {}", display_comma_separated(exprs.as_slice())) } PipeOperator::Set { assignments } => { write!(f, "SET {}", display_comma_separated(assignments.as_slice())) } PipeOperator::Drop { columns } => { write!(f, "DROP {}", display_comma_separated(columns.as_slice())) } PipeOperator::As { alias } => { write!(f, "AS {alias}") } PipeOperator::Limit { expr, offset } => { write!(f, "LIMIT {expr}")?; if let Some(offset) = offset { write!(f, " OFFSET {offset}")?; } Ok(()) } PipeOperator::Aggregate { full_table_exprs, group_by_expr, } => { write!(f, "AGGREGATE")?; if !full_table_exprs.is_empty() { write!( f, " {}", display_comma_separated(full_table_exprs.as_slice()) )?; } if !group_by_expr.is_empty() { write!(f, " GROUP BY {}", display_comma_separated(group_by_expr))?; } Ok(()) } PipeOperator::Where { expr } => { write!(f, "WHERE {expr}") } PipeOperator::OrderBy { exprs } => { write!(f, "ORDER BY {}", display_comma_separated(exprs.as_slice())) } PipeOperator::TableSample { sample } => { write!(f, "{sample}") } PipeOperator::Rename { mappings } => { write!(f, "RENAME {}", display_comma_separated(mappings)) } PipeOperator::Union { set_quantifier, queries, } => Self::fmt_set_operation(f, "UNION", set_quantifier, queries), PipeOperator::Intersect { set_quantifier, queries, } => Self::fmt_set_operation(f, "INTERSECT", set_quantifier, queries), PipeOperator::Except { set_quantifier, queries, } => Self::fmt_set_operation(f, "EXCEPT", set_quantifier, queries), PipeOperator::Call { function, alias } => { write!(f, "CALL {function}")?; Self::fmt_optional_alias(f, alias) } PipeOperator::Pivot { aggregate_functions, value_column, value_source, alias, } => { write!( f, "PIVOT({} FOR {} IN ({}))", display_comma_separated(aggregate_functions), Expr::CompoundIdentifier(value_column.to_vec()), value_source )?; Self::fmt_optional_alias(f, alias) } PipeOperator::Unpivot { value_column, name_column, unpivot_columns, alias, } => { write!( f, "UNPIVOT({} FOR {} IN ({}))", value_column, name_column, display_comma_separated(unpivot_columns) )?; Self::fmt_optional_alias(f, alias) } PipeOperator::Join(join) => write!(f, "{join}"), } } } impl PipeOperator { /// Helper function to format optional alias for pipe operators fn fmt_optional_alias(f: &mut fmt::Formatter<'_>, alias: &Option) -> fmt::Result { if let Some(alias) = alias { write!(f, " AS {alias}")?; } Ok(()) } /// Helper function to format set operations (UNION, INTERSECT, EXCEPT) with queries fn fmt_set_operation( f: &mut fmt::Formatter<'_>, operation: &str, set_quantifier: &SetQuantifier, queries: &[Query], ) -> fmt::Result { write!(f, "{operation}")?; match set_quantifier { SetQuantifier::None => {} _ => { write!(f, " {set_quantifier}")?; } } write!(f, " ")?; let parenthesized_queries: Vec = queries.iter().map(|query| format!("({query})")).collect(); write!(f, "{}", display_comma_separated(&parenthesized_queries)) } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// `FETCH` clause options. pub struct Fetch { /// `WITH TIES` option is present. pub with_ties: bool, /// `PERCENT` modifier is present. pub percent: bool, /// Optional quantity expression (e.g. `FETCH FIRST 10 ROWS`). pub quantity: Option, } impl fmt::Display for Fetch { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let extension = if self.with_ties { "WITH TIES" } else { "ONLY" }; if let Some(ref quantity) = self.quantity { let percent = if self.percent { " PERCENT" } else { "" }; write!(f, "FETCH FIRST {quantity}{percent} ROWS {extension}") } else { write!(f, "FETCH FIRST ROWS {extension}") } } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// `FOR ...` locking clause. pub struct LockClause { /// The kind of lock requested (e.g. `SHARE`, `UPDATE`). pub lock_type: LockType, /// Optional object name after `OF` (e.g. `FOR UPDATE OF t1`). pub of: Option, /// Optional non-blocking behavior (`NOWAIT` / `SKIP LOCKED`). pub nonblock: Option, } impl fmt::Display for LockClause { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "FOR {}", &self.lock_type)?; if let Some(ref of) = self.of { write!(f, " OF {of}")?; } if let Some(ref nb) = self.nonblock { write!(f, " {nb}")?; } Ok(()) } } #[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// The lock type used in `FOR ` clauses (e.g. `FOR SHARE`, `FOR UPDATE`). pub enum LockType { /// `SHARE` lock (shared lock). Share, /// `UPDATE` lock (exclusive/update lock). Update, } impl fmt::Display for LockType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let select_lock = match self { LockType::Share => "SHARE", LockType::Update => "UPDATE", }; write!(f, "{select_lock}") } } #[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Non-blocking lock options for `FOR ...` clauses. pub enum NonBlock { /// `NOWAIT` — do not wait for the lock. Nowait, /// `SKIP LOCKED` — skip rows that are locked. SkipLocked, } impl fmt::Display for NonBlock { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let nonblock = match self { NonBlock::Nowait => "NOWAIT", NonBlock::SkipLocked => "SKIP LOCKED", }; write!(f, "{nonblock}") } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// `ALL`, `DISTINCT`, or `DISTINCT ON (...)` modifiers for `SELECT` lists. pub enum Distinct { /// `ALL` (keep duplicate rows) /// /// Generally this is the default if omitted, but omission should be represented as /// `None::>` All, /// `DISTINCT` (remove duplicate rows) Distinct, /// `DISTINCT ON (...)` (Postgres extension) On(Vec), } impl fmt::Display for Distinct { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { Distinct::All => write!(f, "ALL"), Distinct::Distinct => write!(f, "DISTINCT"), Distinct::On(col_names) => { let col_names = display_comma_separated(col_names); write!(f, "DISTINCT ON ({col_names})") } } } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// MSSQL `TOP` clause options. pub struct Top { /// SQL semantic equivalent of LIMIT but with same structure as FETCH. /// MSSQL only. pub with_ties: bool, /// Apply `PERCENT` extension. pub percent: bool, /// The optional quantity (expression or constant) following `TOP`. pub quantity: Option, } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Quantity used in a `TOP` clause: either an expression or a constant. pub enum TopQuantity { /// A parenthesized expression (MSSQL syntax: `TOP (expr)`). Expr(Expr), /// An unparenthesized integer constant: `TOP 10`. Constant(u64), } impl fmt::Display for Top { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let extension = if self.with_ties { " WITH TIES" } else { "" }; if let Some(ref quantity) = self.quantity { let percent = if self.percent { " PERCENT" } else { "" }; match quantity { TopQuantity::Expr(quantity) => write!(f, "TOP ({quantity}){percent}{extension}"), TopQuantity::Constant(quantity) => { write!(f, "TOP {quantity}{percent}{extension}") } } } else { write!(f, "TOP{extension}") } } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// An explicit `VALUES` clause and its rows. pub struct Values { /// Was there an explicit `ROW` keyword (MySQL)? /// pub explicit_row: bool, /// `true` if `VALUE` (singular) keyword was used instead of `VALUES`. /// pub value_keyword: bool, /// The list of rows, each row is a list of expressions. pub rows: Vec>>, } impl fmt::Display for Values { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self.value_keyword { true => f.write_str("VALUE")?, false => f.write_str("VALUES")?, }; let prefix = if self.explicit_row { "ROW" } else { "" }; let mut delim = ""; for row in &self.rows { f.write_str(delim)?; delim = ","; SpaceOrNewline.fmt(f)?; Indent(format_args!("{prefix}({})", display_comma_separated(row))).fmt(f)?; } Ok(()) } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// `SELECT INTO` clause options. pub struct SelectInto { /// `TEMPORARY` modifier. pub temporary: bool, /// `UNLOGGED` modifier. pub unlogged: bool, /// `TABLE` keyword present. pub table: bool, /// Name of the target table. pub name: ObjectName, } impl fmt::Display for SelectInto { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let temporary = if self.temporary { " TEMPORARY" } else { "" }; let unlogged = if self.unlogged { " UNLOGGED" } else { "" }; let table = if self.table { " TABLE" } else { "" }; write!(f, "INTO{}{}{} {}", temporary, unlogged, table, self.name) } } /// ClickHouse supports GROUP BY WITH modifiers(includes ROLLUP|CUBE|TOTALS). /// e.g. GROUP BY year WITH ROLLUP WITH TOTALS /// /// [ClickHouse]: #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Modifiers used with `GROUP BY` such as `WITH ROLLUP` or `WITH CUBE`. pub enum GroupByWithModifier { /// `WITH ROLLUP` modifier. Rollup, /// `WITH CUBE` modifier. Cube, /// `WITH TOTALS` modifier (ClickHouse). Totals, /// Hive supports GROUPING SETS syntax, e.g. `GROUP BY GROUPING SETS(...)`. /// /// [Hive]: GroupingSets(Expr), } impl fmt::Display for GroupByWithModifier { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { GroupByWithModifier::Rollup => write!(f, "WITH ROLLUP"), GroupByWithModifier::Cube => write!(f, "WITH CUBE"), GroupByWithModifier::Totals => write!(f, "WITH TOTALS"), GroupByWithModifier::GroupingSets(expr) => { write!(f, "{expr}") } } } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Represents the two syntactic forms that `GROUP BY` can take, including /// `GROUP BY ALL` with optional modifiers and ordinary `GROUP BY `. pub enum GroupByExpr { /// ALL syntax of [Snowflake], [DuckDB] and [ClickHouse]. /// /// [Snowflake]: /// [DuckDB]: /// [ClickHouse]: /// /// ClickHouse also supports WITH modifiers after GROUP BY ALL and expressions. /// /// [ClickHouse]: All(Vec), /// `GROUP BY ` with optional modifiers. Expressions(Vec, Vec), } impl fmt::Display for GroupByExpr { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { GroupByExpr::All(modifiers) => { write!(f, "GROUP BY ALL")?; if !modifiers.is_empty() { write!(f, " {}", display_separated(modifiers, " "))?; } Ok(()) } GroupByExpr::Expressions(col_names, modifiers) => { f.write_str("GROUP BY")?; SpaceOrNewline.fmt(f)?; Indent(display_comma_separated(col_names)).fmt(f)?; if !modifiers.is_empty() { write!(f, " {}", display_separated(modifiers, " "))?; } Ok(()) } } } } /// `FORMAT` identifier or `FORMAT NULL` clause, specific to ClickHouse. /// /// [ClickHouse]: #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum FormatClause { /// The format identifier. Identifier(Ident), /// `FORMAT NULL` clause. Null, } impl fmt::Display for FormatClause { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { FormatClause::Identifier(ident) => write!(f, "FORMAT {ident}"), FormatClause::Null => write!(f, "FORMAT NULL"), } } } /// FORMAT identifier in input context, specific to ClickHouse. /// /// [ClickHouse]: #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct InputFormatClause { /// The format identifier. pub ident: Ident, /// Optional format parameters. pub values: Vec, } impl fmt::Display for InputFormatClause { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "FORMAT {}", self.ident)?; if !self.values.is_empty() { write!(f, " {}", display_comma_separated(self.values.as_slice()))?; } Ok(()) } } /// `FOR XML` or `FOR JSON` clause (MSSQL): formats the output of a query as XML or JSON. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum ForClause { /// `FOR BROWSE` clause. Browse, /// `FOR JSON ...` clause and its options. Json { /// JSON mode (`AUTO` or `PATH`). for_json: ForJson, /// Optional `ROOT('...')` parameter. root: Option, /// `INCLUDE_NULL_VALUES` flag. include_null_values: bool, /// `WITHOUT_ARRAY_WRAPPER` flag. without_array_wrapper: bool, }, /// `FOR XML ...` clause and its options. Xml { /// XML mode (`RAW`, `AUTO`, `EXPLICIT`, `PATH`). for_xml: ForXml, /// `ELEMENTS` flag. elements: bool, /// `BINARY BASE64` flag. binary_base64: bool, /// Optional `ROOT('...')` parameter. root: Option, /// `TYPE` flag. r#type: bool, }, } impl fmt::Display for ForClause { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { ForClause::Browse => write!(f, "FOR BROWSE"), ForClause::Json { for_json, root, include_null_values, without_array_wrapper, } => { write!(f, "FOR JSON ")?; write!(f, "{for_json}")?; if let Some(root) = root { write!(f, ", ROOT('{root}')")?; } if *include_null_values { write!(f, ", INCLUDE_NULL_VALUES")?; } if *without_array_wrapper { write!(f, ", WITHOUT_ARRAY_WRAPPER")?; } Ok(()) } ForClause::Xml { for_xml, elements, binary_base64, root, r#type, } => { write!(f, "FOR XML ")?; write!(f, "{for_xml}")?; if *binary_base64 { write!(f, ", BINARY BASE64")?; } if *r#type { write!(f, ", TYPE")?; } if let Some(root) = root { write!(f, ", ROOT('{root}')")?; } if *elements { write!(f, ", ELEMENTS")?; } Ok(()) } } } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Modes for `FOR XML` clause. pub enum ForXml { /// `RAW` mode with optional root name: `RAW('root')`. Raw(Option), /// `AUTO` mode. Auto, /// `EXPLICIT` mode. Explicit, /// `PATH` mode with optional root: `PATH('root')`. Path(Option), } impl fmt::Display for ForXml { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { ForXml::Raw(root) => { write!(f, "RAW")?; if let Some(root) = root { write!(f, "('{root}')")?; } Ok(()) } ForXml::Auto => write!(f, "AUTO"), ForXml::Explicit => write!(f, "EXPLICIT"), ForXml::Path(root) => { write!(f, "PATH")?; if let Some(root) = root { write!(f, "('{root}')")?; } Ok(()) } } } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] /// Modes for `FOR JSON` clause. pub enum ForJson { /// `AUTO` mode. Auto, /// `PATH` mode. Path, } impl fmt::Display for ForJson { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { ForJson::Auto => write!(f, "AUTO"), ForJson::Path => write!(f, "PATH"), } } } /// A single column definition in MySQL's `JSON_TABLE` table valued function. /// /// See /// - [MySQL's JSON_TABLE documentation](https://dev.mysql.com/doc/refman/8.0/en/json-table-functions.html#function_json-table) /// - [Oracle's JSON_TABLE documentation](https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/JSON_TABLE.html) /// - [MariaDB's JSON_TABLE documentation](https://mariadb.com/kb/en/json_table/) /// /// ```sql /// SELECT * /// FROM JSON_TABLE( /// '["a", "b"]', /// '$[*]' COLUMNS ( /// name FOR ORDINALITY, /// value VARCHAR(20) PATH '$', /// NESTED PATH '$[*]' COLUMNS ( /// value VARCHAR(20) PATH '$' /// ) /// ) /// ) AS jt; /// ``` #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] pub enum JsonTableColumn { /// A named column with a JSON path Named(JsonTableNamedColumn), /// The FOR ORDINALITY column, which is a special column that returns the index of the current row in a JSON array. ForOrdinality(Ident), /// A set of nested columns, which extracts data from a nested JSON array. Nested(JsonTableNestedColumn), } impl fmt::Display for JsonTableColumn { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { JsonTableColumn::Named(json_table_named_column) => { write!(f, "{json_table_named_column}") } JsonTableColumn::ForOrdinality(ident) => write!(f, "{ident} FOR ORDINALITY"), JsonTableColumn::Nested(json_table_nested_column) => { write!(f, "{json_table_nested_column}") } } } } /// A nested column in a JSON_TABLE column list /// /// See #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] /// A nested column in a `JSON_TABLE` column list. pub struct JsonTableNestedColumn { /// JSON path expression (must be a literal `Value`). pub path: ValueWithSpan, /// Columns extracted from the matched nested array. pub columns: Vec, } impl fmt::Display for JsonTableNestedColumn { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!( f, "NESTED PATH {} COLUMNS ({})", self.path, display_comma_separated(&self.columns) ) } } /// A single column definition in MySQL's `JSON_TABLE` table valued function. /// /// See /// /// ```sql /// value VARCHAR(20) PATH '$' /// ``` #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] pub struct JsonTableNamedColumn { /// The name of the column to be extracted. pub name: Ident, /// The type of the column to be extracted. pub r#type: DataType, /// The path to the column to be extracted. Must be a literal string. pub path: ValueWithSpan, /// true if the column is a boolean set to true if the given path exists pub exists: bool, /// The empty handling clause of the column pub on_empty: Option, /// The error handling clause of the column pub on_error: Option, } impl fmt::Display for JsonTableNamedColumn { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "{} {}{} PATH {}", self.name, self.r#type, if self.exists { " EXISTS" } else { "" }, self.path )?; if let Some(on_empty) = &self.on_empty { write!(f, " {on_empty} ON EMPTY")?; } if let Some(on_error) = &self.on_error { write!(f, " {on_error} ON ERROR")?; } Ok(()) } } /// Stores the error handling clause of a `JSON_TABLE` table valued function: /// {NULL | DEFAULT json_string | ERROR} ON {ERROR | EMPTY } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] /// Error/empty-value handling for `JSON_TABLE` columns. pub enum JsonTableColumnErrorHandling { /// `NULL` — return NULL when the path does not match. Null, /// `DEFAULT ` — use the provided `Value` as a default. Default(ValueWithSpan), /// `ERROR` — raise an error. Error, } impl fmt::Display for JsonTableColumnErrorHandling { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { JsonTableColumnErrorHandling::Null => write!(f, "NULL"), JsonTableColumnErrorHandling::Default(json_string) => { write!(f, "DEFAULT {json_string}") } JsonTableColumnErrorHandling::Error => write!(f, "ERROR"), } } } /// A single column definition in MSSQL's `OPENJSON WITH` clause. /// /// ```sql /// colName type [ column_path ] [ AS JSON ] /// ``` /// /// Reference: #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] pub struct OpenJsonTableColumn { /// The name of the column to be extracted. pub name: Ident, /// The type of the column to be extracted. pub r#type: DataType, /// The path to the column to be extracted. Must be a literal string. pub path: Option, /// The `AS JSON` option. pub as_json: bool, } impl fmt::Display for OpenJsonTableColumn { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{} {}", self.name, self.r#type)?; if let Some(path) = &self.path { write!(f, " '{}'", value::escape_single_quote_string(path))?; } if self.as_json { write!(f, " AS JSON")?; } Ok(()) } } /// BigQuery supports ValueTables which have 2 modes: /// `SELECT [ALL | DISTINCT] AS STRUCT` /// `SELECT [ALL | DISTINCT] AS VALUE` /// /// /// #[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Mode of BigQuery value tables, e.g. `AS STRUCT` or `AS VALUE`. pub enum ValueTableMode { /// `AS STRUCT` AsStruct, /// `AS VALUE` AsValue, /// `DISTINCT AS STRUCT` DistinctAsStruct, /// `DISTINCT AS VALUE` DistinctAsValue, } impl fmt::Display for ValueTableMode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { ValueTableMode::AsStruct => write!(f, "AS STRUCT"), ValueTableMode::AsValue => write!(f, "AS VALUE"), ValueTableMode::DistinctAsStruct => write!(f, "DISTINCT AS STRUCT"), ValueTableMode::DistinctAsValue => write!(f, "DISTINCT AS VALUE"), } } } /// The `FROM` clause of an `UPDATE TABLE` statement #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum UpdateTableFromKind { /// Update Statement where the 'FROM' clause is before the 'SET' keyword (Supported by Snowflake) /// For Example: `UPDATE FROM t1 SET t1.name='aaa'` BeforeSet(Vec), /// Update Statement where the 'FROM' clause is after the 'SET' keyword (Which is the standard way) /// For Example: `UPDATE SET t1.name='aaa' FROM t1` AfterSet(Vec), } /// Defines the options for an XmlTable column: Named or ForOrdinality #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] pub enum XmlTableColumnOption { /// A named column with a type, optional path, and default value. NamedInfo { /// The type of the column to be extracted. r#type: DataType, /// The path to the column to be extracted. If None, defaults to the column name. path: Option, /// Default value if path does not match default: Option, /// Whether the column is nullable (NULL=true, NOT NULL=false) nullable: bool, }, /// The FOR ORDINALITY marker ForOrdinality, } /// A single column definition in XMLTABLE /// /// ```sql /// COLUMNS /// id int PATH '@id', /// ordinality FOR ORDINALITY, /// "COUNTRY_NAME" text, /// country_id text PATH 'COUNTRY_ID', /// size_sq_km float PATH 'SIZE[@unit = "sq_km"]', /// size_other text PATH 'concat(SIZE[@unit!="sq_km"], " ", SIZE[@unit!="sq_km"]/@unit)', /// premier_name text PATH 'PREMIER_NAME' DEFAULT 'not specified' /// ``` #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] pub struct XmlTableColumn { /// The name of the column. pub name: Ident, /// Column options: type/path/default or FOR ORDINALITY pub option: XmlTableColumnOption, } impl fmt::Display for XmlTableColumn { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "{}", self.name)?; match &self.option { XmlTableColumnOption::NamedInfo { r#type, path, default, nullable, } => { write!(f, " {type}")?; if let Some(p) = path { write!(f, " PATH {p}")?; } if let Some(d) = default { write!(f, " DEFAULT {d}")?; } if !*nullable { write!(f, " NOT NULL")?; } Ok(()) } XmlTableColumnOption::ForOrdinality => { write!(f, " FOR ORDINALITY") } } } } /// Argument passed in the XMLTABLE PASSING clause #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] /// Argument passed in the `XMLTABLE PASSING` clause. pub struct XmlPassingArgument { /// Expression to pass to the XML table. pub expr: Expr, /// Optional alias for the argument. pub alias: Option, /// `true` if `BY VALUE` is specified for the argument. pub by_value: bool, } impl fmt::Display for XmlPassingArgument { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { if self.by_value { write!(f, "BY VALUE ")?; } write!(f, "{}", self.expr)?; if let Some(alias) = &self.alias { write!(f, " AS {alias}")?; } Ok(()) } } /// The PASSING clause for XMLTABLE #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] /// The PASSING clause for `XMLTABLE`. pub struct XmlPassingClause { /// The list of passed arguments. pub arguments: Vec, } impl fmt::Display for XmlPassingClause { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { if !self.arguments.is_empty() { write!(f, " PASSING {}", display_comma_separated(&self.arguments))?; } Ok(()) } } /// Represents a single XML namespace definition in the XMLNAMESPACES clause. /// /// `namespace_uri AS namespace_name` #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] pub struct XmlNamespaceDefinition { /// The namespace URI (a text expression). pub uri: Expr, /// The alias for the namespace (a simple identifier). pub name: Ident, } impl fmt::Display for XmlNamespaceDefinition { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "{} AS {}", self.uri, self.name) } } apache-datafusion-sqlparser-rs-0.62.0/src/ast/spans.rs000066400000000000000000003121231517524037000226650ustar00rootroot00000000000000// 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 crate::{ ast::{ ddl::AlterSchema, query::SelectItemQualifiedWildcardKind, AlterSchemaOperation, AlterTable, ColumnOptions, CreateOperator, CreateOperatorClass, CreateOperatorFamily, CreateView, ExportData, Owner, TypedString, }, tokenizer::TokenWithSpan, }; use core::iter; use crate::tokenizer::Span; use super::{ comments, dcl::SecondaryRoles, value::ValueWithSpan, AccessExpr, AlterColumnOperation, AlterIndexOperation, AlterTableOperation, Analyze, Array, Assignment, AssignmentTarget, AttachedToken, BeginEndStatements, CaseStatement, CloseCursor, ClusteredIndex, ColumnDef, ColumnOption, ColumnOptionDef, ConditionalStatementBlock, ConditionalStatements, ConflictTarget, ConnectByKind, ConstraintCharacteristics, CopySource, CreateIndex, CreateTable, CreateTableOptions, Cte, Delete, DoUpdate, ExceptSelectItem, ExcludeSelectItem, Expr, ExprWithAlias, Fetch, ForValues, FromTable, Function, FunctionArg, FunctionArgExpr, FunctionArgumentClause, FunctionArgumentList, FunctionArguments, GroupByExpr, HavingBound, IfStatement, IlikeSelectItem, IndexColumn, Insert, Interpolate, InterpolateExpr, Join, JoinConstraint, JoinOperator, JsonPath, JsonPathElem, LateralView, LimitClause, MatchRecognizePattern, Measure, Merge, MergeAction, MergeClause, MergeInsertExpr, MergeInsertKind, MergeUpdateExpr, NamedParenthesizedList, NamedWindowDefinition, ObjectName, ObjectNamePart, Offset, OnConflict, OnConflictAction, OnInsert, OpenStatement, OrderBy, OrderByExpr, OrderByKind, OutputClause, Parens, Partition, PartitionBoundValue, PivotValueSource, ProjectionSelect, Query, RaiseStatement, RaiseStatementValue, ReferentialAction, RenameSelectItem, ReplaceSelectElement, ReplaceSelectItem, Select, SelectInto, SelectItem, SetExpr, SqlOption, Statement, Subscript, SymbolDefinition, TableAlias, TableAliasColumnDef, TableConstraint, TableFactor, TableObject, TableOptionsClustered, TableWithJoins, Update, UpdateTableFromKind, Use, Values, ViewColumnDef, WhileStatement, WildcardAdditionalOptions, With, WithFill, }; /// Given an iterator of spans, return the [Span::union] of all spans. fn union_spans>(iter: I) -> Span { Span::union_iter(iter) } /// Trait for AST nodes that have a source location information. /// /// # Notes: /// /// Source [`Span`] are not yet complete. They may be missing: /// /// 1. keywords or other tokens /// 2. span information entirely, in which case they return [`Span::empty()`]. /// /// Note Some impl blocks (rendered below) are annotated with which nodes are /// missing spans. See [this ticket] for additional information and status. /// /// [this ticket]: https://github.com/apache/datafusion-sqlparser-rs/issues/1548 /// /// # Example /// ``` /// # use sqlparser::parser::{Parser, ParserError}; /// # use sqlparser::ast::Spanned; /// # use sqlparser::dialect::GenericDialect; /// # use sqlparser::tokenizer::Location; /// # fn main() -> Result<(), ParserError> { /// let dialect = GenericDialect {}; /// let sql = r#"SELECT * /// FROM table_1"#; /// let statements = Parser::new(&dialect) /// .try_with_sql(sql)? /// .parse_statements()?; /// // Get the span of the first statement (SELECT) /// let span = statements[0].span(); /// // statement starts at line 1, column 1 (1 based, not 0 based) /// assert_eq!(span.start, Location::new(1, 1)); /// // statement ends on line 2, column 15 /// assert_eq!(span.end, Location::new(2, 15)); /// # Ok(()) /// # } /// ``` /// pub trait Spanned { /// Return the [`Span`] (the minimum and maximum [`Location`]) for this AST /// node, by recursively combining the spans of its children. /// /// [`Location`]: crate::tokenizer::Location fn span(&self) -> Span; } impl Spanned for TokenWithSpan { fn span(&self) -> Span { self.span } } impl Spanned for Parens { fn span(&self) -> Span { self.opening_token.0.span.union(&self.closing_token.0.span) } } impl Spanned for Query { fn span(&self) -> Span { let Query { with, body, order_by, limit_clause, fetch, locks: _, // todo for_clause: _, // todo, mssql specific settings: _, // todo, clickhouse specific format_clause: _, // todo, clickhouse specific pipe_operators: _, // todo bigquery specific } = self; union_spans( with.iter() .map(|i| i.span()) .chain(core::iter::once(body.span())) .chain(order_by.as_ref().map(|i| i.span())) .chain(limit_clause.as_ref().map(|i| i.span())) .chain(fetch.as_ref().map(|i| i.span())), ) } } impl Spanned for LimitClause { fn span(&self) -> Span { match self { LimitClause::LimitOffset { limit, offset, limit_by, } => union_spans( limit .iter() .map(|i| i.span()) .chain(offset.as_ref().map(|i| i.span())) .chain(limit_by.iter().map(|i| i.span())), ), LimitClause::OffsetCommaLimit { offset, limit } => offset.span().union(&limit.span()), } } } impl Spanned for Offset { fn span(&self) -> Span { let Offset { value, rows: _, // enum } = self; value.span() } } impl Spanned for Fetch { fn span(&self) -> Span { let Fetch { with_ties: _, // bool percent: _, // bool quantity, } = self; quantity.as_ref().map_or(Span::empty(), |i| i.span()) } } impl Spanned for With { fn span(&self) -> Span { let With { with_token, recursive: _, // bool cte_tables, } = self; union_spans( core::iter::once(with_token.0.span).chain(cte_tables.iter().map(|item| item.span())), ) } } impl Spanned for Cte { fn span(&self) -> Span { let Cte { alias, query, from, materialized: _, // enum closing_paren_token, } = self; union_spans( core::iter::once(alias.span()) .chain(core::iter::once(query.span())) .chain(from.iter().map(|item| item.span)) .chain(core::iter::once(closing_paren_token.0.span)), ) } } /// # partial span /// /// [SetExpr::Table] is not implemented. impl Spanned for SetExpr { fn span(&self) -> Span { match self { SetExpr::Select(select) => select.span(), SetExpr::Query(query) => query.span(), SetExpr::SetOperation { op: _, set_quantifier: _, left, right, } => left.span().union(&right.span()), SetExpr::Values(values) => values.span(), SetExpr::Insert(statement) => statement.span(), SetExpr::Table(_) => Span::empty(), SetExpr::Update(statement) => statement.span(), SetExpr::Delete(statement) => statement.span(), SetExpr::Merge(statement) => statement.span(), } } } impl Spanned for Values { fn span(&self) -> Span { let Values { explicit_row: _, // bool, value_keyword: _, rows, } = self; match &rows[..] { [] => Span::empty(), [f] => f.span(), [f, .., l] => f.span().union(&l.span()), } } } /// # partial span /// /// Missing spans: /// - [Statement::CopyIntoSnowflake] /// - [Statement::CreateSecret] /// - [Statement::CreateRole] /// - [Statement::AlterType] /// - [Statement::AlterOperator] /// - [Statement::AlterRole] /// - [Statement::AttachDatabase] /// - [Statement::AttachDuckDBDatabase] /// - [Statement::DetachDuckDBDatabase] /// - [Statement::Drop] /// - [Statement::DropFunction] /// - [Statement::DropProcedure] /// - [Statement::DropSecret] /// - [Statement::Declare] /// - [Statement::CreateExtension] /// - [Statement::CreateCollation] /// - [Statement::AlterCollation] /// - [Statement::Fetch] /// - [Statement::Flush] /// - [Statement::Discard] /// - [Statement::Set] /// - [Statement::ShowFunctions] /// - [Statement::ShowVariable] /// - [Statement::ShowStatus] /// - [Statement::ShowVariables] /// - [Statement::ShowCreate] /// - [Statement::ShowColumns] /// - [Statement::ShowTables] /// - [Statement::ShowCollation] /// - [Statement::StartTransaction] /// - [Statement::Comment] /// - [Statement::Commit] /// - [Statement::Rollback] /// - [Statement::CreateSchema] /// - [Statement::CreateDatabase] /// - [Statement::CreateFunction] /// - [Statement::CreateTrigger] /// - [Statement::DropTrigger] /// - [Statement::CreateProcedure] /// - [Statement::CreateMacro] /// - [Statement::CreateStage] /// - [Statement::Assert] /// - [Statement::Grant] /// - [Statement::Revoke] /// - [Statement::Deallocate] /// - [Statement::Execute] /// - [Statement::Prepare] /// - [Statement::Kill] /// - [Statement::ExplainTable] /// - [Statement::Explain] /// - [Statement::Savepoint] /// - [Statement::ReleaseSavepoint] /// - [Statement::Cache] /// - [Statement::UNCache] /// - [Statement::CreateSequence] /// - [Statement::CreateType] /// - [Statement::Pragma] /// - [Statement::Lock] /// - [Statement::LockTables] /// - [Statement::UnlockTables] /// - [Statement::Unload] /// - [Statement::OptimizeTable] impl Spanned for Statement { fn span(&self) -> Span { match self { Statement::Analyze(analyze) => analyze.span(), Statement::Truncate(truncate) => truncate.span(), Statement::Msck(msck) => msck.span(), Statement::Query(query) => query.span(), Statement::Insert(insert) => insert.span(), Statement::Install { extension_name } => extension_name.span, Statement::Load { extension_name } => extension_name.span, Statement::Directory { overwrite: _, local: _, path: _, file_format: _, source, } => source.span(), Statement::Case(stmt) => stmt.span(), Statement::If(stmt) => stmt.span(), Statement::While(stmt) => stmt.span(), Statement::Raise(stmt) => stmt.span(), Statement::Call(function) => function.span(), Statement::Copy { source, to: _, target: _, options: _, legacy_options: _, values: _, } => source.span(), Statement::CopyIntoSnowflake { into: _, into_columns: _, from_obj: _, from_obj_alias: _, stage_params: _, from_transformations: _, files: _, pattern: _, file_format: _, copy_options: _, validation_mode: _, kind: _, from_query: _, partition: _, } => Span::empty(), Statement::Open(open) => open.span(), Statement::Close { cursor } => match cursor { CloseCursor::All => Span::empty(), CloseCursor::Specific { name } => name.span, }, Statement::Update(update) => update.span(), Statement::Delete(delete) => delete.span(), Statement::CreateView(create_view) => create_view.span(), Statement::CreateTable(create_table) => create_table.span(), Statement::CreateVirtualTable { name, if_not_exists: _, module_name, module_args, } => union_spans( core::iter::once(name.span()) .chain(core::iter::once(module_name.span)) .chain(module_args.iter().map(|i| i.span)), ), Statement::CreateIndex(create_index) => create_index.span(), Statement::CreateRole(create_role) => create_role.span(), Statement::CreateExtension(create_extension) => create_extension.span(), Statement::CreateCollation(create_collation) => create_collation.span(), Statement::DropExtension(drop_extension) => drop_extension.span(), Statement::DropOperator(drop_operator) => drop_operator.span(), Statement::DropOperatorFamily(drop_operator_family) => drop_operator_family.span(), Statement::DropOperatorClass(drop_operator_class) => drop_operator_class.span(), Statement::CreateSecret { .. } => Span::empty(), Statement::CreateServer { .. } => Span::empty(), Statement::CreateConnector { .. } => Span::empty(), Statement::CreateOperator(create_operator) => create_operator.span(), Statement::CreateOperatorFamily(create_operator_family) => { create_operator_family.span() } Statement::CreateOperatorClass(create_operator_class) => create_operator_class.span(), Statement::AlterTable(alter_table) => alter_table.span(), Statement::AlterIndex { name, operation } => name.span().union(&operation.span()), Statement::AlterView { name, columns, query, with_options, } => union_spans( core::iter::once(name.span()) .chain(columns.iter().map(|i| i.span)) .chain(core::iter::once(query.span())) .chain(with_options.iter().map(|i| i.span())), ), // These statements need to be implemented Statement::AlterFunction { .. } => Span::empty(), Statement::AlterType { .. } => Span::empty(), Statement::AlterCollation { .. } => Span::empty(), Statement::AlterOperator { .. } => Span::empty(), Statement::AlterOperatorFamily { .. } => Span::empty(), Statement::AlterOperatorClass { .. } => Span::empty(), Statement::AlterRole { .. } => Span::empty(), Statement::AlterSession { .. } => Span::empty(), Statement::AttachDatabase { .. } => Span::empty(), Statement::AttachDuckDBDatabase { .. } => Span::empty(), Statement::DetachDuckDBDatabase { .. } => Span::empty(), Statement::Drop { .. } => Span::empty(), Statement::DropFunction(drop_function) => drop_function.span(), Statement::DropDomain { .. } => Span::empty(), Statement::DropProcedure { .. } => Span::empty(), Statement::DropSecret { .. } => Span::empty(), Statement::Declare { .. } => Span::empty(), Statement::Fetch { .. } => Span::empty(), Statement::Flush { .. } => Span::empty(), Statement::Discard { .. } => Span::empty(), Statement::Set(_) => Span::empty(), Statement::ShowFunctions { .. } => Span::empty(), Statement::ShowVariable { .. } => Span::empty(), Statement::ShowStatus { .. } => Span::empty(), Statement::ShowVariables { .. } => Span::empty(), Statement::ShowCreate { .. } => Span::empty(), Statement::ShowColumns { .. } => Span::empty(), Statement::ShowTables { .. } => Span::empty(), Statement::ShowCollation { .. } => Span::empty(), Statement::ShowCharset { .. } => Span::empty(), Statement::Use(u) => u.span(), Statement::StartTransaction { .. } => Span::empty(), Statement::Comment { .. } => Span::empty(), Statement::Commit { .. } => Span::empty(), Statement::Rollback { .. } => Span::empty(), Statement::CreateSchema { .. } => Span::empty(), Statement::CreateDatabase { .. } => Span::empty(), Statement::CreateFunction { .. } => Span::empty(), Statement::CreateDomain { .. } => Span::empty(), Statement::CreateTrigger { .. } => Span::empty(), Statement::DropTrigger { .. } => Span::empty(), Statement::CreateProcedure { .. } => Span::empty(), Statement::CreateMacro { .. } => Span::empty(), Statement::CreateStage { .. } => Span::empty(), Statement::Assert { .. } => Span::empty(), Statement::Grant { .. } => Span::empty(), Statement::Deny { .. } => Span::empty(), Statement::Revoke { .. } => Span::empty(), Statement::Deallocate { .. } => Span::empty(), Statement::Execute { .. } => Span::empty(), Statement::Prepare { .. } => Span::empty(), Statement::Kill { .. } => Span::empty(), Statement::ExplainTable { .. } => Span::empty(), Statement::Explain { .. } => Span::empty(), Statement::Savepoint { .. } => Span::empty(), Statement::ReleaseSavepoint { .. } => Span::empty(), Statement::Merge(merge) => merge.span(), Statement::Cache { .. } => Span::empty(), Statement::UNCache { .. } => Span::empty(), Statement::CreateSequence { .. } => Span::empty(), Statement::CreateType { .. } => Span::empty(), Statement::Pragma { .. } => Span::empty(), Statement::Lock(_) => Span::empty(), Statement::LockTables { .. } => Span::empty(), Statement::UnlockTables => Span::empty(), Statement::Unload { .. } => Span::empty(), Statement::OptimizeTable { .. } => Span::empty(), Statement::CreatePolicy { .. } => Span::empty(), Statement::AlterPolicy { .. } => Span::empty(), Statement::AlterConnector { .. } => Span::empty(), Statement::DropPolicy { .. } => Span::empty(), Statement::DropConnector { .. } => Span::empty(), Statement::ShowCatalogs { .. } => Span::empty(), Statement::ShowDatabases { .. } => Span::empty(), Statement::ShowProcessList { .. } => Span::empty(), Statement::ShowSchemas { .. } => Span::empty(), Statement::ShowObjects { .. } => Span::empty(), Statement::ShowViews { .. } => Span::empty(), Statement::LISTEN { .. } => Span::empty(), Statement::NOTIFY { .. } => Span::empty(), Statement::LoadData { .. } => Span::empty(), Statement::UNLISTEN { .. } => Span::empty(), Statement::RenameTable { .. } => Span::empty(), Statement::RaisError { .. } => Span::empty(), Statement::Throw(_) => Span::empty(), Statement::Print { .. } => Span::empty(), Statement::WaitFor(_) => Span::empty(), Statement::Return { .. } => Span::empty(), Statement::List(..) | Statement::Remove(..) => Span::empty(), Statement::ExportData(ExportData { options, query, connection, }) => union_spans( options .iter() .map(|i| i.span()) .chain(core::iter::once(query.span())) .chain(connection.iter().map(|i| i.span())), ), Statement::CreateUser(..) => Span::empty(), Statement::AlterSchema(s) => s.span(), Statement::Vacuum(..) => Span::empty(), Statement::AlterUser(..) => Span::empty(), Statement::Reset(..) => Span::empty(), } } } impl Spanned for Use { fn span(&self) -> Span { match self { Use::Catalog(object_name) => object_name.span(), Use::Schema(object_name) => object_name.span(), Use::Database(object_name) => object_name.span(), Use::Warehouse(object_name) => object_name.span(), Use::Role(object_name) => object_name.span(), Use::SecondaryRoles(secondary_roles) => { if let SecondaryRoles::List(roles) = secondary_roles { return union_spans(roles.iter().map(|i| i.span)); } Span::empty() } Use::Object(object_name) => object_name.span(), Use::Default => Span::empty(), } } } impl Spanned for CreateTable { fn span(&self) -> Span { let CreateTable { or_replace: _, // bool temporary: _, // bool external: _, // bool global: _, // bool dynamic: _, // bool if_not_exists: _, // bool transient: _, // bool volatile: _, // bool iceberg: _, // bool, Snowflake specific snapshot: _, // bool, BigQuery specific name, columns, constraints, hive_distribution: _, // hive specific hive_formats: _, // hive specific file_format: _, // enum location: _, // string, no span query, without_rowid: _, // bool like: _, clone, comment: _, // todo, no span on_commit: _, on_cluster: _, // todo, clickhouse specific primary_key: _, // todo, clickhouse specific order_by: _, // todo, clickhouse specific partition_by: _, // todo, BigQuery specific cluster_by: _, // todo, BigQuery specific clustered_by: _, // todo, Hive specific inherits: _, // todo, PostgreSQL specific partition_of, for_values, strict: _, // bool copy_grants: _, // bool enable_schema_evolution: _, // bool change_tracking: _, // bool data_retention_time_in_days: _, // u64, no span max_data_extension_time_in_days: _, // u64, no span default_ddl_collation: _, // string, no span with_aggregation_policy: _, // todo, Snowflake specific with_row_access_policy: _, // todo, Snowflake specific with_storage_lifecycle_policy: _, // todo, Snowflake specific with_tags: _, // todo, Snowflake specific external_volume: _, // todo, Snowflake specific base_location: _, // todo, Snowflake specific catalog: _, // todo, Snowflake specific catalog_sync: _, // todo, Snowflake specific storage_serialization_policy: _, table_options, target_lag: _, warehouse: _, version: _, refresh_mode: _, initialize: _, require_user: _, diststyle: _, distkey: _, sortkey: _, backup: _, } = self; union_spans( core::iter::once(name.span()) .chain(core::iter::once(table_options.span())) .chain(columns.iter().map(|i| i.span())) .chain(constraints.iter().map(|i| i.span())) .chain(query.iter().map(|i| i.span())) .chain(clone.iter().map(|i| i.span())) .chain(partition_of.iter().map(|i| i.span())) .chain(for_values.iter().map(|i| i.span())), ) } } impl Spanned for ColumnDef { fn span(&self) -> Span { let ColumnDef { name, data_type: _, // enum options, } = self; union_spans(core::iter::once(name.span).chain(options.iter().map(|i| i.span()))) } } impl Spanned for ColumnOptionDef { fn span(&self) -> Span { let ColumnOptionDef { name, option } = self; option.span().union_opt(&name.as_ref().map(|i| i.span)) } } impl Spanned for TableConstraint { fn span(&self) -> Span { match self { TableConstraint::Unique(constraint) => constraint.span(), TableConstraint::PrimaryKey(constraint) => constraint.span(), TableConstraint::ForeignKey(constraint) => constraint.span(), TableConstraint::Check(constraint) => constraint.span(), TableConstraint::Index(constraint) => constraint.span(), TableConstraint::FulltextOrSpatial(constraint) => constraint.span(), TableConstraint::PrimaryKeyUsingIndex(constraint) | TableConstraint::UniqueUsingIndex(constraint) => constraint.span(), } } } impl Spanned for PartitionBoundValue { fn span(&self) -> Span { match self { PartitionBoundValue::Expr(expr) => expr.span(), // MINVALUE and MAXVALUE are keywords without tracked spans PartitionBoundValue::MinValue => Span::empty(), PartitionBoundValue::MaxValue => Span::empty(), } } } impl Spanned for ForValues { fn span(&self) -> Span { match self { ForValues::In(exprs) => union_spans(exprs.iter().map(|e| e.span())), ForValues::From { from, to } => union_spans( from.iter() .map(|v| v.span()) .chain(to.iter().map(|v| v.span())), ), // WITH (MODULUS n, REMAINDER r) - u64 values have no spans ForValues::With { .. } => Span::empty(), ForValues::Default => Span::empty(), } } } impl Spanned for CreateIndex { fn span(&self) -> Span { let CreateIndex { name, table_name, using: _, columns, unique: _, // bool concurrently: _, // bool if_not_exists: _, // bool include, nulls_distinct: _, // bool with, predicate, index_options: _, alter_options, } = self; union_spans( name.iter() .map(|i| i.span()) .chain(core::iter::once(table_name.span())) .chain(columns.iter().map(|i| i.column.span())) .chain(include.iter().map(|i| i.span)) .chain(with.iter().map(|i| i.span())) .chain(predicate.iter().map(|i| i.span())) .chain(alter_options.iter().map(|i| i.span())), ) } } impl Spanned for IndexColumn { fn span(&self) -> Span { self.column.span() } } impl Spanned for CaseStatement { fn span(&self) -> Span { let CaseStatement { case_token: AttachedToken(start), match_expr: _, when_blocks: _, else_block: _, end_case_token: AttachedToken(end), } = self; union_spans([start.span, end.span].into_iter()) } } impl Spanned for IfStatement { fn span(&self) -> Span { let IfStatement { if_block, elseif_blocks, else_block, end_token, } = self; union_spans( iter::once(if_block.span()) .chain(elseif_blocks.iter().map(|b| b.span())) .chain(else_block.as_ref().map(|b| b.span())) .chain(end_token.as_ref().map(|AttachedToken(t)| t.span)), ) } } impl Spanned for WhileStatement { fn span(&self) -> Span { let WhileStatement { while_block } = self; while_block.span() } } impl Spanned for ConditionalStatements { fn span(&self) -> Span { match self { ConditionalStatements::Sequence { statements } => { union_spans(statements.iter().map(|s| s.span())) } ConditionalStatements::BeginEnd(bes) => bes.span(), } } } impl Spanned for ConditionalStatementBlock { fn span(&self) -> Span { let ConditionalStatementBlock { start_token: AttachedToken(start_token), condition, then_token, conditional_statements, } = self; union_spans( iter::once(start_token.span) .chain(condition.as_ref().map(|c| c.span())) .chain(then_token.as_ref().map(|AttachedToken(t)| t.span)) .chain(iter::once(conditional_statements.span())), ) } } impl Spanned for RaiseStatement { fn span(&self) -> Span { let RaiseStatement { value } = self; union_spans(value.iter().map(|value| value.span())) } } impl Spanned for RaiseStatementValue { fn span(&self) -> Span { match self { RaiseStatementValue::UsingMessage(expr) => expr.span(), RaiseStatementValue::Expr(expr) => expr.span(), } } } /// # partial span /// /// Missing spans: /// - [ColumnOption::Null] /// - [ColumnOption::NotNull] /// - [ColumnOption::Comment] /// - [ColumnOption::PrimaryKey] /// - [ColumnOption::Unique] /// - [ColumnOption::DialectSpecific] /// - [ColumnOption::Generated] impl Spanned for ColumnOption { fn span(&self) -> Span { match self { ColumnOption::Null => Span::empty(), ColumnOption::NotNull => Span::empty(), ColumnOption::Default(expr) => expr.span(), ColumnOption::Materialized(expr) => expr.span(), ColumnOption::Ephemeral(expr) => expr.as_ref().map_or(Span::empty(), |e| e.span()), ColumnOption::Alias(expr) => expr.span(), ColumnOption::PrimaryKey(constraint) => constraint.span(), ColumnOption::Unique(constraint) => constraint.span(), ColumnOption::Check(constraint) => constraint.span(), ColumnOption::ForeignKey(constraint) => constraint.span(), ColumnOption::DialectSpecific(_) => Span::empty(), ColumnOption::CharacterSet(object_name) => object_name.span(), ColumnOption::Collation(object_name) => object_name.span(), ColumnOption::Comment(_) => Span::empty(), ColumnOption::OnUpdate(expr) => expr.span(), ColumnOption::Generated { .. } => Span::empty(), ColumnOption::Options(vec) => union_spans(vec.iter().map(|i| i.span())), ColumnOption::Identity(..) => Span::empty(), ColumnOption::OnConflict(..) => Span::empty(), ColumnOption::Policy(..) => Span::empty(), ColumnOption::Tags(..) => Span::empty(), ColumnOption::Srid(..) => Span::empty(), ColumnOption::Invisible => Span::empty(), } } } /// # missing span impl Spanned for ReferentialAction { fn span(&self) -> Span { Span::empty() } } /// # missing span impl Spanned for ConstraintCharacteristics { fn span(&self) -> Span { let ConstraintCharacteristics { deferrable: _, // bool initially: _, // enum enforced: _, // bool } = self; Span::empty() } } impl Spanned for Analyze { fn span(&self) -> Span { union_spans( self.table_name .iter() .map(|t| t.span()) .chain( self.partitions .iter() .flat_map(|i| i.iter().map(|k| k.span())), ) .chain(self.columns.iter().map(|i| i.span)), ) } } /// # partial span /// /// Missing spans: /// - [AlterColumnOperation::SetNotNull] /// - [AlterColumnOperation::DropNotNull] /// - [AlterColumnOperation::DropDefault] /// - [AlterColumnOperation::AddGenerated] impl Spanned for AlterColumnOperation { fn span(&self) -> Span { match self { AlterColumnOperation::SetNotNull => Span::empty(), AlterColumnOperation::DropNotNull => Span::empty(), AlterColumnOperation::SetDefault { value } => value.span(), AlterColumnOperation::DropDefault => Span::empty(), AlterColumnOperation::SetDataType { data_type: _, using, had_set: _, } => using.as_ref().map_or(Span::empty(), |u| u.span()), AlterColumnOperation::AddGenerated { .. } => Span::empty(), } } } impl Spanned for CopySource { fn span(&self) -> Span { match self { CopySource::Table { table_name, columns, } => union_spans( core::iter::once(table_name.span()).chain(columns.iter().map(|i| i.span)), ), CopySource::Query(query) => query.span(), } } } impl Spanned for Delete { fn span(&self) -> Span { let Delete { delete_token, optimizer_hints: _, tables, from, using, selection, returning, output, order_by, limit, } = self; union_spans( core::iter::once(delete_token.0.span).chain( tables .iter() .map(|i| i.span()) .chain(core::iter::once(from.span())) .chain( using .iter() .map(|u| union_spans(u.iter().map(|i| i.span()))), ) .chain(selection.iter().map(|i| i.span())) .chain(returning.iter().flat_map(|i| i.iter().map(|k| k.span()))) .chain(output.iter().map(|i| i.span())) .chain(order_by.iter().map(|i| i.span())) .chain(limit.iter().map(|i| i.span())), ), ) } } impl Spanned for Update { fn span(&self) -> Span { let Update { update_token, optimizer_hints: _, table, assignments, from, selection, returning, output, or: _, order_by, limit, } = self; union_spans( core::iter::once(table.span()) .chain(core::iter::once(update_token.0.span)) .chain(assignments.iter().map(|i| i.span())) .chain(from.iter().map(|i| i.span())) .chain(selection.iter().map(|i| i.span())) .chain(returning.iter().flat_map(|i| i.iter().map(|k| k.span()))) .chain(output.iter().map(|i| i.span())) .chain(order_by.iter().map(|i| i.span())) .chain(limit.iter().map(|i| i.span())), ) } } impl Spanned for Merge { fn span(&self) -> Span { union_spans( [self.merge_token.0.span, self.on.span()] .into_iter() .chain(self.clauses.iter().map(Spanned::span)) .chain(self.output.iter().map(Spanned::span)), ) } } impl Spanned for FromTable { fn span(&self) -> Span { match self { FromTable::WithFromKeyword(vec) => union_spans(vec.iter().map(|i| i.span())), FromTable::WithoutKeyword(vec) => union_spans(vec.iter().map(|i| i.span())), } } } impl Spanned for ViewColumnDef { fn span(&self) -> Span { let ViewColumnDef { name, data_type: _, // todo, DataType options, } = self; name.span.union_opt(&options.as_ref().map(|o| o.span())) } } impl Spanned for ColumnOptions { fn span(&self) -> Span { union_spans(self.as_slice().iter().map(|i| i.span())) } } impl Spanned for SqlOption { fn span(&self) -> Span { match self { SqlOption::Clustered(table_options_clustered) => table_options_clustered.span(), SqlOption::Ident(ident) => ident.span, SqlOption::KeyValue { key, value } => key.span.union(&value.span()), SqlOption::Partition { column_name, range_direction: _, for_values, } => union_spans( core::iter::once(column_name.span).chain(for_values.iter().map(|i| i.span())), ), SqlOption::TableSpace(_) => Span::empty(), SqlOption::Comment(_) => Span::empty(), SqlOption::NamedParenthesizedList(NamedParenthesizedList { key: name, name: value, values, }) => union_spans(core::iter::once(name.span).chain(values.iter().map(|i| i.span))) .union_opt(&value.as_ref().map(|i| i.span)), } } } /// # partial span /// /// Missing spans: /// - [TableOptionsClustered::ColumnstoreIndex] impl Spanned for TableOptionsClustered { fn span(&self) -> Span { match self { TableOptionsClustered::ColumnstoreIndex => Span::empty(), TableOptionsClustered::ColumnstoreIndexOrder(vec) => { union_spans(vec.iter().map(|i| i.span)) } TableOptionsClustered::Index(vec) => union_spans(vec.iter().map(|i| i.span())), } } } impl Spanned for ClusteredIndex { fn span(&self) -> Span { let ClusteredIndex { name, asc: _, // bool } = self; name.span } } impl Spanned for CreateTableOptions { fn span(&self) -> Span { match self { CreateTableOptions::None => Span::empty(), CreateTableOptions::With(vec) => union_spans(vec.iter().map(|i| i.span())), CreateTableOptions::Options(vec) => { union_spans(vec.as_slice().iter().map(|i| i.span())) } CreateTableOptions::Plain(vec) => union_spans(vec.iter().map(|i| i.span())), CreateTableOptions::TableProperties(vec) => union_spans(vec.iter().map(|i| i.span())), } } } /// # partial span /// /// Missing spans: /// - [AlterTableOperation::OwnerTo] impl Spanned for AlterTableOperation { fn span(&self) -> Span { match self { AlterTableOperation::AddConstraint { constraint, not_valid: _, } => constraint.span(), AlterTableOperation::AddColumn { column_keyword: _, if_not_exists: _, column_def, column_position: _, } => column_def.span(), AlterTableOperation::AddProjection { if_not_exists: _, name, select, } => name.span.union(&select.span()), AlterTableOperation::DropProjection { if_exists: _, name } => name.span, AlterTableOperation::MaterializeProjection { if_exists: _, name, partition, } => name.span.union_opt(&partition.as_ref().map(|i| i.span)), AlterTableOperation::ClearProjection { if_exists: _, name, partition, } => name.span.union_opt(&partition.as_ref().map(|i| i.span)), AlterTableOperation::DisableRowLevelSecurity => Span::empty(), AlterTableOperation::DisableRule { name } => name.span, AlterTableOperation::DisableTrigger { name } => name.span, AlterTableOperation::DropConstraint { if_exists: _, name, drop_behavior: _, } => name.span, AlterTableOperation::DropColumn { has_column_keyword: _, column_names, if_exists: _, drop_behavior: _, } => union_spans(column_names.iter().map(|i| i.span)), AlterTableOperation::AttachPartition { partition } => partition.span(), AlterTableOperation::DetachPartition { partition } => partition.span(), AlterTableOperation::FreezePartition { partition, with_name, } => partition .span() .union_opt(&with_name.as_ref().map(|n| n.span)), AlterTableOperation::UnfreezePartition { partition, with_name, } => partition .span() .union_opt(&with_name.as_ref().map(|n| n.span)), AlterTableOperation::DropPrimaryKey { .. } => Span::empty(), AlterTableOperation::DropForeignKey { name, .. } => name.span, AlterTableOperation::DropIndex { name } => name.span, AlterTableOperation::EnableAlwaysRule { name } => name.span, AlterTableOperation::EnableAlwaysTrigger { name } => name.span, AlterTableOperation::EnableReplicaRule { name } => name.span, AlterTableOperation::EnableReplicaTrigger { name } => name.span, AlterTableOperation::EnableRowLevelSecurity => Span::empty(), AlterTableOperation::ForceRowLevelSecurity => Span::empty(), AlterTableOperation::NoForceRowLevelSecurity => Span::empty(), AlterTableOperation::EnableRule { name } => name.span, AlterTableOperation::EnableTrigger { name } => name.span, AlterTableOperation::RenamePartitions { old_partitions, new_partitions, } => union_spans( old_partitions .iter() .map(|i| i.span()) .chain(new_partitions.iter().map(|i| i.span())), ), AlterTableOperation::AddPartitions { if_not_exists: _, new_partitions, } => union_spans(new_partitions.iter().map(|i| i.span())), AlterTableOperation::DropPartitions { partitions, if_exists: _, } => union_spans(partitions.iter().map(|i| i.span())), AlterTableOperation::RenameColumn { old_column_name, new_column_name, } => old_column_name.span.union(&new_column_name.span), AlterTableOperation::RenameTable { table_name } => table_name.span(), AlterTableOperation::ChangeColumn { old_name, new_name, data_type: _, options, column_position: _, } => union_spans( core::iter::once(old_name.span) .chain(core::iter::once(new_name.span)) .chain(options.iter().map(|i| i.span())), ), AlterTableOperation::ModifyColumn { col_name, data_type: _, options, column_position: _, } => { union_spans(core::iter::once(col_name.span).chain(options.iter().map(|i| i.span()))) } AlterTableOperation::RenameConstraint { old_name, new_name } => { old_name.span.union(&new_name.span) } AlterTableOperation::AlterColumn { column_name, op } => { column_name.span.union(&op.span()) } AlterTableOperation::SwapWith { table_name } => table_name.span(), AlterTableOperation::SetTblProperties { table_properties } => { union_spans(table_properties.iter().map(|i| i.span())) } AlterTableOperation::OwnerTo { .. } => Span::empty(), AlterTableOperation::ClusterBy { exprs } => union_spans(exprs.iter().map(|e| e.span())), AlterTableOperation::DropClusteringKey => Span::empty(), AlterTableOperation::AlterSortKey { .. } => Span::empty(), AlterTableOperation::SuspendRecluster => Span::empty(), AlterTableOperation::ResumeRecluster => Span::empty(), AlterTableOperation::Refresh { .. } => Span::empty(), AlterTableOperation::Suspend => Span::empty(), AlterTableOperation::Resume => Span::empty(), AlterTableOperation::Algorithm { .. } => Span::empty(), AlterTableOperation::AutoIncrement { value, .. } => value.span(), AlterTableOperation::Lock { .. } => Span::empty(), AlterTableOperation::ReplicaIdentity { .. } => Span::empty(), AlterTableOperation::ValidateConstraint { name } => name.span, AlterTableOperation::SetOptionsParens { options } => { union_spans(options.iter().map(|i| i.span())) } } } } impl Spanned for Partition { fn span(&self) -> Span { match self { Partition::Identifier(ident) => ident.span, Partition::Expr(expr) => expr.span(), Partition::Part(expr) => expr.span(), Partition::Partitions(vec) => union_spans(vec.iter().map(|i| i.span())), } } } impl Spanned for ProjectionSelect { fn span(&self) -> Span { let ProjectionSelect { projection, order_by, group_by, } = self; union_spans( projection .iter() .map(|i| i.span()) .chain(order_by.iter().map(|i| i.span())) .chain(group_by.iter().map(|i| i.span())), ) } } /// # partial span /// /// Missing spans: /// - [OrderByKind::All] impl Spanned for OrderBy { fn span(&self) -> Span { match &self.kind { OrderByKind::All(_) => Span::empty(), OrderByKind::Expressions(exprs) => union_spans( exprs .iter() .map(|i| i.span()) .chain(self.interpolate.iter().map(|i| i.span())), ), } } } /// # partial span /// /// Missing spans: /// - [GroupByExpr::All] impl Spanned for GroupByExpr { fn span(&self) -> Span { match self { GroupByExpr::All(_) => Span::empty(), GroupByExpr::Expressions(exprs, _modifiers) => { union_spans(exprs.iter().map(|i| i.span())) } } } } impl Spanned for Interpolate { fn span(&self) -> Span { let Interpolate { exprs } = self; union_spans(exprs.iter().flat_map(|i| i.iter().map(|e| e.span()))) } } impl Spanned for InterpolateExpr { fn span(&self) -> Span { let InterpolateExpr { column, expr } = self; column.span.union_opt(&expr.as_ref().map(|e| e.span())) } } impl Spanned for AlterIndexOperation { fn span(&self) -> Span { match self { AlterIndexOperation::RenameIndex { index_name } => index_name.span(), } } } /// # partial span /// /// Missing spans:ever /// - [Insert::insert_alias] impl Spanned for Insert { fn span(&self) -> Span { let Insert { insert_token, optimizer_hints: _, or: _, // enum, sqlite specific ignore: _, // bool into: _, // bool table, table_alias, columns, overwrite: _, // bool source, partitioned, after_columns, has_table_keyword: _, // bool on, returning, output, replace_into: _, // bool priority: _, // todo, mysql specific insert_alias: _, // todo, mysql specific assignments, settings: _, // todo, clickhouse specific format_clause: _, // todo, clickhouse specific multi_table_insert_type: _, // snowflake multi-table insert multi_table_into_clauses: _, // snowflake multi-table insert multi_table_when_clauses: _, // snowflake multi-table insert multi_table_else_clause: _, // snowflake multi-table insert } = self; union_spans( core::iter::once(insert_token.0.span) .chain(core::iter::once(table.span())) .chain(table_alias.iter().map(|k| k.alias.span)) .chain(columns.iter().map(|i| i.span())) .chain(source.as_ref().map(|q| q.span())) .chain(assignments.iter().map(|i| i.span())) .chain(partitioned.iter().flat_map(|i| i.iter().map(|k| k.span()))) .chain(after_columns.iter().map(|i| i.span)) .chain(on.as_ref().map(|i| i.span())) .chain(returning.iter().flat_map(|i| i.iter().map(|k| k.span()))) .chain(output.iter().map(|i| i.span())), ) } } impl Spanned for OnInsert { fn span(&self) -> Span { match self { OnInsert::DuplicateKeyUpdate(vec) => union_spans(vec.iter().map(|i| i.span())), OnInsert::OnConflict(on_conflict) => on_conflict.span(), } } } impl Spanned for OnConflict { fn span(&self) -> Span { let OnConflict { conflict_target, action, } = self; action .span() .union_opt(&conflict_target.as_ref().map(|i| i.span())) } } impl Spanned for ConflictTarget { fn span(&self) -> Span { match self { ConflictTarget::Columns(vec) => union_spans(vec.iter().map(|i| i.span)), ConflictTarget::OnConstraint(object_name) => object_name.span(), } } } /// # partial span /// /// Missing spans: /// - [OnConflictAction::DoNothing] impl Spanned for OnConflictAction { fn span(&self) -> Span { match self { OnConflictAction::DoNothing => Span::empty(), OnConflictAction::DoUpdate(do_update) => do_update.span(), } } } impl Spanned for DoUpdate { fn span(&self) -> Span { let DoUpdate { assignments, selection, } = self; union_spans( assignments .iter() .map(|i| i.span()) .chain(selection.iter().map(|i| i.span())), ) } } impl Spanned for Assignment { fn span(&self) -> Span { let Assignment { target, value } = self; target.span().union(&value.span()) } } impl Spanned for AssignmentTarget { fn span(&self) -> Span { match self { AssignmentTarget::ColumnName(object_name) => object_name.span(), AssignmentTarget::Tuple(vec) => union_spans(vec.iter().map(|i| i.span())), } } } /// # partial span /// /// Most expressions are missing keywords in their spans. /// f.e. `IS NULL ` reports as `::span`. /// /// Missing spans: /// - [Expr::MatchAgainst] # MySQL specific /// - [Expr::RLike] # MySQL specific /// - [Expr::Struct] # BigQuery specific /// - [Expr::Named] # BigQuery specific /// - [Expr::Dictionary] # DuckDB specific /// - [Expr::Map] # DuckDB specific /// - [Expr::Lambda] impl Spanned for Expr { fn span(&self) -> Span { match self { Expr::Identifier(ident) => ident.span, Expr::CompoundIdentifier(vec) => union_spans(vec.iter().map(|i| i.span)), Expr::CompoundFieldAccess { root, access_chain } => { union_spans(iter::once(root.span()).chain(access_chain.iter().map(|i| i.span()))) } Expr::IsFalse(expr) => expr.span(), Expr::IsNotFalse(expr) => expr.span(), Expr::IsTrue(expr) => expr.span(), Expr::IsNotTrue(expr) => expr.span(), Expr::IsNull(expr) => expr.span(), Expr::IsNotNull(expr) => expr.span(), Expr::IsUnknown(expr) => expr.span(), Expr::IsNotUnknown(expr) => expr.span(), Expr::IsDistinctFrom(lhs, rhs) => lhs.span().union(&rhs.span()), Expr::IsNotDistinctFrom(lhs, rhs) => lhs.span().union(&rhs.span()), Expr::InList { expr, list, negated: _, } => union_spans( core::iter::once(expr.span()).chain(list.iter().map(|item| item.span())), ), Expr::InSubquery { expr, subquery, negated: _, } => expr.span().union(&subquery.span()), Expr::InUnnest { expr, array_expr, negated: _, } => expr.span().union(&array_expr.span()), Expr::Between { expr, negated: _, low, high, } => expr.span().union(&low.span()).union(&high.span()), Expr::BinaryOp { left, op: _, right } => left.span().union(&right.span()), Expr::Like { negated: _, expr, pattern, escape_char: _, any: _, } => expr.span().union(&pattern.span()), Expr::ILike { negated: _, expr, pattern, escape_char: _, any: _, } => expr.span().union(&pattern.span()), Expr::RLike { .. } => Span::empty(), Expr::IsNormalized { expr, form: _, negated: _, } => expr.span(), Expr::SimilarTo { negated: _, expr, pattern, escape_char: _, } => expr.span().union(&pattern.span()), Expr::Ceil { expr, field: _ } => expr.span(), Expr::Floor { expr, field: _ } => expr.span(), Expr::Position { expr, r#in } => expr.span().union(&r#in.span()), Expr::Overlay { expr, overlay_what, overlay_from, overlay_for, } => expr .span() .union(&overlay_what.span()) .union(&overlay_from.span()) .union_opt(&overlay_for.as_ref().map(|i| i.span())), Expr::Collate { expr, collation } => expr .span() .union(&union_spans(collation.0.iter().map(|i| i.span()))), Expr::Nested(expr) => expr.span(), Expr::Value(value) => value.span(), Expr::TypedString(TypedString { value, .. }) => value.span(), Expr::Function(function) => function.span(), Expr::GroupingSets(vec) => { union_spans(vec.iter().flat_map(|i| i.iter().map(|k| k.span()))) } Expr::Cube(vec) => union_spans(vec.iter().flat_map(|i| i.iter().map(|k| k.span()))), Expr::Rollup(vec) => union_spans(vec.iter().flat_map(|i| i.iter().map(|k| k.span()))), Expr::Tuple(vec) => union_spans(vec.iter().map(|i| i.span())), Expr::Array(array) => array.span(), Expr::MatchAgainst { .. } => Span::empty(), Expr::JsonAccess { value, path } => value.span().union(&path.span()), Expr::AnyOp { left, compare_op: _, right, is_some: _, } => left.span().union(&right.span()), Expr::AllOp { left, compare_op: _, right, } => left.span().union(&right.span()), Expr::UnaryOp { op: _, expr } => expr.span(), Expr::Convert { expr, data_type: _, charset, target_before_value: _, styles, is_try: _, } => union_spans( core::iter::once(expr.span()) .chain(charset.as_ref().map(|i| i.span())) .chain(styles.iter().map(|i| i.span())), ), Expr::Cast { kind: _, expr, data_type: _, array: _, format: _, } => expr.span(), Expr::AtTimeZone { timestamp, time_zone, } => timestamp.span().union(&time_zone.span()), Expr::Extract { field: _, syntax: _, expr, } => expr.span(), Expr::Substring { expr, substring_from, substring_for, special: _, shorthand: _, } => union_spans( core::iter::once(expr.span()) .chain(substring_from.as_ref().map(|i| i.span())) .chain(substring_for.as_ref().map(|i| i.span())), ), Expr::Trim { expr, trim_where: _, trim_what, trim_characters, } => union_spans( core::iter::once(expr.span()) .chain(trim_what.as_ref().map(|i| i.span())) .chain( trim_characters .as_ref() .map(|items| union_spans(items.iter().map(|i| i.span()))), ), ), Expr::Prefixed { value, .. } => value.span(), Expr::Case { case_token, end_token, operand, conditions, else_result, } => union_spans( iter::once(case_token.0.span) .chain( operand .as_ref() .map(|i| i.span()) .into_iter() .chain(conditions.iter().flat_map(|case_when| { [case_when.condition.span(), case_when.result.span()] })) .chain(else_result.as_ref().map(|i| i.span())), ) .chain(iter::once(end_token.0.span)), ), Expr::Exists { subquery, .. } => subquery.span(), Expr::Subquery(query) => query.span(), Expr::Struct { .. } => Span::empty(), Expr::Named { .. } => Span::empty(), Expr::Dictionary(_) => Span::empty(), Expr::Map(_) => Span::empty(), Expr::Interval(interval) => interval.value.span(), Expr::Wildcard(token) => token.0.span, Expr::QualifiedWildcard(object_name, token) => union_spans( object_name .0 .iter() .map(|i| i.span()) .chain(iter::once(token.0.span)), ), Expr::OuterJoin(expr) => expr.span(), Expr::Prior(expr) => expr.span(), Expr::Lambda(_) => Span::empty(), Expr::MemberOf(member_of) => member_of.value.span().union(&member_of.array.span()), } } } impl Spanned for Subscript { fn span(&self) -> Span { match self { Subscript::Index { index } => index.span(), Subscript::Slice { lower_bound, upper_bound, stride, } => union_spans( [ lower_bound.as_ref().map(|i| i.span()), upper_bound.as_ref().map(|i| i.span()), stride.as_ref().map(|i| i.span()), ] .into_iter() .flatten(), ), } } } impl Spanned for AccessExpr { fn span(&self) -> Span { match self { AccessExpr::Dot(ident) => ident.span(), AccessExpr::Subscript(subscript) => subscript.span(), } } } impl Spanned for ObjectName { fn span(&self) -> Span { let ObjectName(segments) = self; union_spans(segments.iter().map(|i| i.span())) } } impl Spanned for ObjectNamePart { fn span(&self) -> Span { match self { ObjectNamePart::Identifier(ident) => ident.span, ObjectNamePart::Function(func) => func .name .span .union(&union_spans(func.args.iter().map(|i| i.span()))), } } } impl Spanned for Array { fn span(&self) -> Span { let Array { elem, named: _, // bool } = self; union_spans(elem.iter().map(|i| i.span())) } } impl Spanned for Function { fn span(&self) -> Span { let Function { name, uses_odbc_syntax: _, parameters, args, filter, null_treatment: _, // enum over: _, // todo within_group, } = self; union_spans( name.0 .iter() .map(|i| i.span()) .chain(iter::once(args.span())) .chain(iter::once(parameters.span())) .chain(filter.iter().map(|i| i.span())) .chain(within_group.iter().map(|i| i.span())), ) } } /// # partial span /// /// The span of [FunctionArguments::None] is empty. impl Spanned for FunctionArguments { fn span(&self) -> Span { match self { FunctionArguments::None => Span::empty(), FunctionArguments::Subquery(query) => query.span(), FunctionArguments::List(list) => list.span(), } } } impl Spanned for FunctionArgumentList { fn span(&self) -> Span { let FunctionArgumentList { duplicate_treatment: _, // enum args, clauses, } = self; union_spans( // # todo: duplicate-treatment span args.iter() .map(|i| i.span()) .chain(clauses.iter().map(|i| i.span())), ) } } impl Spanned for FunctionArgumentClause { fn span(&self) -> Span { match self { FunctionArgumentClause::IgnoreOrRespectNulls(_) => Span::empty(), FunctionArgumentClause::OrderBy(vec) => union_spans(vec.iter().map(|i| i.expr.span())), FunctionArgumentClause::Limit(expr) => expr.span(), FunctionArgumentClause::OnOverflow(_) => Span::empty(), FunctionArgumentClause::Having(HavingBound(_kind, expr)) => expr.span(), FunctionArgumentClause::Separator(value) => value.span(), FunctionArgumentClause::JsonNullClause(_) => Span::empty(), FunctionArgumentClause::JsonReturningClause(_) => Span::empty(), } } } /// # partial span /// /// see Spanned impl for JsonPathElem for more information impl Spanned for JsonPath { fn span(&self) -> Span { let JsonPath { path } = self; union_spans(path.iter().map(|i| i.span())) } } /// # partial span /// /// Missing spans: /// - [JsonPathElem::Dot] impl Spanned for JsonPathElem { fn span(&self) -> Span { match self { JsonPathElem::Dot { .. } => Span::empty(), JsonPathElem::Bracket { key } => key.span(), JsonPathElem::ColonBracket { key } => key.span(), } } } impl Spanned for SelectItemQualifiedWildcardKind { fn span(&self) -> Span { match self { SelectItemQualifiedWildcardKind::ObjectName(object_name) => object_name.span(), SelectItemQualifiedWildcardKind::Expr(expr) => expr.span(), } } } impl Spanned for SelectItem { fn span(&self) -> Span { match self { SelectItem::UnnamedExpr(expr) => expr.span(), SelectItem::ExprWithAlias { expr, alias } => expr.span().union(&alias.span), SelectItem::ExprWithAliases { expr, aliases } => { union_spans(iter::once(expr.span()).chain(aliases.iter().map(|i| i.span))) } SelectItem::QualifiedWildcard(kind, wildcard_additional_options) => union_spans( [kind.span()] .into_iter() .chain(iter::once(wildcard_additional_options.span())), ), SelectItem::Wildcard(wildcard_additional_options) => wildcard_additional_options.span(), } } } impl Spanned for WildcardAdditionalOptions { fn span(&self) -> Span { let WildcardAdditionalOptions { wildcard_token, opt_ilike, opt_exclude, opt_except, opt_replace, opt_rename, opt_alias, } = self; union_spans( core::iter::once(wildcard_token.0.span) .chain(opt_ilike.as_ref().map(|i| i.span())) .chain(opt_exclude.as_ref().map(|i| i.span())) .chain(opt_rename.as_ref().map(|i| i.span())) .chain(opt_replace.as_ref().map(|i| i.span())) .chain(opt_except.as_ref().map(|i| i.span())) .chain(opt_alias.as_ref().map(|i| i.span)), ) } } /// # missing span impl Spanned for IlikeSelectItem { fn span(&self) -> Span { Span::empty() } } impl Spanned for ExcludeSelectItem { fn span(&self) -> Span { match self { ExcludeSelectItem::Single(name) => name.span(), ExcludeSelectItem::Multiple(vec) => union_spans(vec.iter().map(|i| i.span())), } } } impl Spanned for RenameSelectItem { fn span(&self) -> Span { match self { RenameSelectItem::Single(ident) => ident.ident.span.union(&ident.alias.span), RenameSelectItem::Multiple(vec) => { union_spans(vec.iter().map(|i| i.ident.span.union(&i.alias.span))) } } } } impl Spanned for ExceptSelectItem { fn span(&self) -> Span { let ExceptSelectItem { first_element, additional_elements, } = self; union_spans( iter::once(first_element.span).chain(additional_elements.iter().map(|i| i.span)), ) } } impl Spanned for ReplaceSelectItem { fn span(&self) -> Span { let ReplaceSelectItem { items } = self; union_spans(items.iter().map(|i| i.span())) } } impl Spanned for ReplaceSelectElement { fn span(&self) -> Span { let ReplaceSelectElement { expr, column_name, as_keyword: _, // bool } = self; expr.span().union(&column_name.span) } } /// # partial span /// /// Missing spans: /// - [TableFactor::JsonTable] impl Spanned for TableFactor { fn span(&self) -> Span { match self { TableFactor::Table { name, alias, args: _, with_hints: _, version: _, with_ordinality: _, partitions: _, json_path: _, sample: _, index_hints: _, } => union_spans( name.0 .iter() .map(|i| i.span()) .chain(alias.as_ref().map(|alias| { union_spans( iter::once(alias.name.span) .chain(alias.columns.iter().map(|i| i.span())), ) })), ), TableFactor::Derived { lateral: _, subquery, alias, sample: _, } => subquery .span() .union_opt(&alias.as_ref().map(|alias| alias.span())), TableFactor::TableFunction { expr, alias } => expr .span() .union_opt(&alias.as_ref().map(|alias| alias.span())), TableFactor::UNNEST { alias, with_offset: _, with_offset_alias, array_exprs, with_ordinality: _, } => union_spans( alias .iter() .map(|i| i.span()) .chain(array_exprs.iter().map(|i| i.span())) .chain(with_offset_alias.as_ref().map(|i| i.span)), ), TableFactor::NestedJoin { table_with_joins, alias, } => table_with_joins .span() .union_opt(&alias.as_ref().map(|alias| alias.span())), TableFactor::Function { lateral: _, name, args, with_ordinality: _, alias, } => union_spans( name.0 .iter() .map(|i| i.span()) .chain(args.iter().map(|i| i.span())) .chain(alias.as_ref().map(|alias| alias.span())), ), TableFactor::JsonTable { .. } => Span::empty(), TableFactor::XmlTable { .. } => Span::empty(), TableFactor::Pivot { table, aggregate_functions, value_column, value_source, default_on_null, alias, } => union_spans( core::iter::once(table.span()) .chain(aggregate_functions.iter().map(|i| i.span())) .chain(value_column.iter().map(|i| i.span())) .chain(core::iter::once(value_source.span())) .chain(default_on_null.as_ref().map(|i| i.span())) .chain(alias.as_ref().map(|i| i.span())), ), TableFactor::Unpivot { table, value, null_inclusion: _, name, columns, alias, } => union_spans( core::iter::once(table.span()) .chain(core::iter::once(value.span())) .chain(core::iter::once(name.span)) .chain(columns.iter().map(|ilist| ilist.span())) .chain(alias.as_ref().map(|alias| alias.span())), ), TableFactor::MatchRecognize { table, partition_by, order_by, measures, rows_per_match: _, after_match_skip: _, pattern, symbols, alias, } => union_spans( core::iter::once(table.span()) .chain(partition_by.iter().map(|i| i.span())) .chain(order_by.iter().map(|i| i.span())) .chain(measures.iter().map(|i| i.span())) .chain(core::iter::once(pattern.span())) .chain(symbols.iter().map(|i| i.span())) .chain(alias.as_ref().map(|i| i.span())), ), TableFactor::SemanticView { name, dimensions, metrics, facts, where_clause, alias, } => union_spans( name.0 .iter() .map(|i| i.span()) .chain(dimensions.iter().map(|d| d.span())) .chain(metrics.iter().map(|m| m.span())) .chain(facts.iter().map(|f| f.span())) .chain(where_clause.as_ref().map(|e| e.span())) .chain(alias.as_ref().map(|a| a.span())), ), TableFactor::OpenJsonTable { .. } => Span::empty(), } } } impl Spanned for PivotValueSource { fn span(&self) -> Span { match self { PivotValueSource::List(vec) => union_spans(vec.iter().map(|i| i.span())), PivotValueSource::Any(vec) => union_spans(vec.iter().map(|i| i.span())), PivotValueSource::Subquery(query) => query.span(), } } } impl Spanned for ExprWithAlias { fn span(&self) -> Span { let ExprWithAlias { expr, alias } = self; expr.span().union_opt(&alias.as_ref().map(|i| i.span)) } } /// # missing span impl Spanned for MatchRecognizePattern { fn span(&self) -> Span { Span::empty() } } impl Spanned for SymbolDefinition { fn span(&self) -> Span { let SymbolDefinition { symbol, definition } = self; symbol.span.union(&definition.span()) } } impl Spanned for Measure { fn span(&self) -> Span { let Measure { expr, alias } = self; expr.span().union(&alias.span) } } impl Spanned for OrderByExpr { fn span(&self) -> Span { let OrderByExpr { expr, options: _, with_fill, } = self; expr.span().union_opt(&with_fill.as_ref().map(|f| f.span())) } } impl Spanned for WithFill { fn span(&self) -> Span { let WithFill { from, to, step } = self; union_spans( from.iter() .map(|f| f.span()) .chain(to.iter().map(|t| t.span())) .chain(step.iter().map(|s| s.span())), ) } } impl Spanned for FunctionArg { fn span(&self) -> Span { match self { FunctionArg::Named { name, arg, operator: _, } => name.span.union(&arg.span()), FunctionArg::Unnamed(arg) => arg.span(), FunctionArg::ExprNamed { name, arg, operator: _, } => name.span().union(&arg.span()), } } } /// # partial span /// /// Missing spans: /// - [FunctionArgExpr::Wildcard] /// - [FunctionArgExpr::WildcardWithOptions] impl Spanned for FunctionArgExpr { fn span(&self) -> Span { match self { FunctionArgExpr::Expr(expr) => expr.span(), FunctionArgExpr::QualifiedWildcard(object_name) => { union_spans(object_name.0.iter().map(|i| i.span())) } FunctionArgExpr::Wildcard => Span::empty(), FunctionArgExpr::WildcardWithOptions(_) => Span::empty(), } } } impl Spanned for TableAlias { fn span(&self) -> Span { let TableAlias { explicit: _, name, columns, at, } = self; union_spans( core::iter::once(name.span) .chain(columns.iter().map(Spanned::span)) .chain(at.iter().map(|at| at.span)), ) } } impl Spanned for TableAliasColumnDef { fn span(&self) -> Span { let TableAliasColumnDef { name, data_type: _ } = self; name.span } } impl Spanned for ValueWithSpan { fn span(&self) -> Span { self.span } } impl Spanned for Join { fn span(&self) -> Span { let Join { relation, global: _, // bool join_operator, } = self; relation.span().union(&join_operator.span()) } } /// # partial span /// /// Missing spans: /// - [JoinOperator::CrossJoin] /// - [JoinOperator::CrossApply] /// - [JoinOperator::OuterApply] impl Spanned for JoinOperator { fn span(&self) -> Span { match self { JoinOperator::Join(join_constraint) => join_constraint.span(), JoinOperator::Inner(join_constraint) => join_constraint.span(), JoinOperator::Left(join_constraint) => join_constraint.span(), JoinOperator::LeftOuter(join_constraint) => join_constraint.span(), JoinOperator::Right(join_constraint) => join_constraint.span(), JoinOperator::RightOuter(join_constraint) => join_constraint.span(), JoinOperator::FullOuter(join_constraint) => join_constraint.span(), JoinOperator::CrossJoin(join_constraint) => join_constraint.span(), JoinOperator::LeftSemi(join_constraint) => join_constraint.span(), JoinOperator::RightSemi(join_constraint) => join_constraint.span(), JoinOperator::LeftAnti(join_constraint) => join_constraint.span(), JoinOperator::RightAnti(join_constraint) => join_constraint.span(), JoinOperator::CrossApply => Span::empty(), JoinOperator::OuterApply => Span::empty(), JoinOperator::AsOf { match_condition, constraint, } => match_condition.span().union(&constraint.span()), JoinOperator::Anti(join_constraint) => join_constraint.span(), JoinOperator::Semi(join_constraint) => join_constraint.span(), JoinOperator::StraightJoin(join_constraint) => join_constraint.span(), JoinOperator::ArrayJoin => Span::empty(), JoinOperator::LeftArrayJoin => Span::empty(), JoinOperator::InnerArrayJoin => Span::empty(), } } } /// # partial span /// /// Missing spans: /// - [JoinConstraint::Natural] /// - [JoinConstraint::None] impl Spanned for JoinConstraint { fn span(&self) -> Span { match self { JoinConstraint::On(expr) => expr.span(), JoinConstraint::Using(vec) => union_spans(vec.iter().map(|i| i.span())), JoinConstraint::Natural => Span::empty(), JoinConstraint::None => Span::empty(), } } } impl Spanned for TableWithJoins { fn span(&self) -> Span { let TableWithJoins { relation, joins } = self; union_spans(core::iter::once(relation.span()).chain(joins.iter().map(|item| item.span()))) } } impl Spanned for Select { fn span(&self) -> Span { let Select { select_token, optimizer_hints: _, distinct: _, // todo select_modifiers: _, top: _, // todo, mysql specific projection, exclude: _, into, from, lateral_views, prewhere, selection, group_by, cluster_by, distribute_by, sort_by, having, named_window, qualify, window_before_qualify: _, // bool value_table_mode: _, // todo, BigQuery specific connect_by, top_before_distinct: _, flavor: _, } = self; union_spans( core::iter::once(select_token.0.span) .chain(projection.iter().map(|item| item.span())) .chain(into.iter().map(|item| item.span())) .chain(from.iter().map(|item| item.span())) .chain(lateral_views.iter().map(|item| item.span())) .chain(prewhere.iter().map(|item| item.span())) .chain(selection.iter().map(|item| item.span())) .chain(connect_by.iter().map(|item| item.span())) .chain(core::iter::once(group_by.span())) .chain(cluster_by.iter().map(|item| item.span())) .chain(distribute_by.iter().map(|item| item.span())) .chain(sort_by.iter().map(|item| item.span())) .chain(having.iter().map(|item| item.span())) .chain(named_window.iter().map(|item| item.span())) .chain(qualify.iter().map(|item| item.span())), ) } } impl Spanned for ConnectByKind { fn span(&self) -> Span { match self { ConnectByKind::ConnectBy { connect_token, nocycle: _, relationships, } => union_spans( core::iter::once(connect_token.0.span()) .chain(relationships.last().iter().map(|item| item.span())), ), ConnectByKind::StartWith { start_token, condition, } => union_spans([start_token.0.span(), condition.span()].into_iter()), } } } impl Spanned for NamedWindowDefinition { fn span(&self) -> Span { let NamedWindowDefinition( ident, _, // todo: NamedWindowExpr ) = self; ident.span } } impl Spanned for LateralView { fn span(&self) -> Span { let LateralView { lateral_view, lateral_view_name, lateral_col_alias, outer: _, // bool } = self; union_spans( core::iter::once(lateral_view.span()) .chain(core::iter::once(lateral_view_name.span())) .chain(lateral_col_alias.iter().map(|i| i.span)), ) } } impl Spanned for SelectInto { fn span(&self) -> Span { let SelectInto { temporary: _, // bool unlogged: _, // bool table: _, // bool name, } = self; name.span() } } impl Spanned for UpdateTableFromKind { fn span(&self) -> Span { let from = match self { UpdateTableFromKind::BeforeSet(from) => from, UpdateTableFromKind::AfterSet(from) => from, }; union_spans(from.iter().map(|t| t.span())) } } impl Spanned for TableObject { fn span(&self) -> Span { match self { TableObject::TableName(ObjectName(segments)) => { union_spans(segments.iter().map(|i| i.span())) } TableObject::TableFunction(func) => func.span(), TableObject::TableQuery(query) => query.span(), } } } impl Spanned for BeginEndStatements { fn span(&self) -> Span { let BeginEndStatements { begin_token, statements, end_token, } = self; union_spans( core::iter::once(begin_token.0.span) .chain(statements.iter().map(|i| i.span())) .chain(core::iter::once(end_token.0.span)), ) } } impl Spanned for OpenStatement { fn span(&self) -> Span { let OpenStatement { cursor_name } = self; cursor_name.span } } impl Spanned for AlterSchemaOperation { fn span(&self) -> Span { match self { AlterSchemaOperation::SetDefaultCollate { collate } => collate.span(), AlterSchemaOperation::AddReplica { replica, options } => union_spans( core::iter::once(replica.span) .chain(options.iter().flat_map(|i| i.iter().map(|i| i.span()))), ), AlterSchemaOperation::DropReplica { replica } => replica.span, AlterSchemaOperation::SetOptionsParens { options } => { union_spans(options.iter().map(|i| i.span())) } AlterSchemaOperation::Rename { name } => name.span(), AlterSchemaOperation::OwnerTo { owner } => { if let Owner::Ident(ident) = owner { ident.span } else { Span::empty() } } } } } impl Spanned for AlterSchema { fn span(&self) -> Span { union_spans( core::iter::once(self.name.span()).chain(self.operations.iter().map(|i| i.span())), ) } } impl Spanned for CreateView { fn span(&self) -> Span { union_spans( core::iter::once(self.name.span()) .chain(self.columns.iter().map(|i| i.span())) .chain(core::iter::once(self.query.span())) .chain(core::iter::once(self.options.span())) .chain(self.cluster_by.iter().map(|i| i.span)) .chain(self.to.iter().map(|i| i.span())), ) } } impl Spanned for AlterTable { fn span(&self) -> Span { union_spans( core::iter::once(self.name.span()) .chain(self.operations.iter().map(|i| i.span())) .chain(self.on_cluster.iter().map(|i| i.span)) .chain(core::iter::once(self.end_token.0.span)), ) } } impl Spanned for CreateOperator { fn span(&self) -> Span { Span::empty() } } impl Spanned for CreateOperatorFamily { fn span(&self) -> Span { Span::empty() } } impl Spanned for CreateOperatorClass { fn span(&self) -> Span { Span::empty() } } impl Spanned for MergeClause { fn span(&self) -> Span { union_spans([self.when_token.0.span, self.action.span()].into_iter()) } } impl Spanned for MergeAction { fn span(&self) -> Span { match self { MergeAction::Insert(expr) => expr.span(), MergeAction::Update(expr) => expr.span(), MergeAction::Delete { delete_token } => delete_token.0.span, } } } impl Spanned for MergeInsertExpr { fn span(&self) -> Span { union_spans( [ self.insert_token.0.span, self.kind_token.0.span, match self.kind { MergeInsertKind::Values(ref values) => values.span(), MergeInsertKind::Row => Span::empty(), // ~ covered by `kind_token` }, ] .into_iter() .chain(self.insert_predicate.iter().map(Spanned::span)) .chain(self.columns.iter().map(|i| i.span())), ) } } impl Spanned for MergeUpdateExpr { fn span(&self) -> Span { union_spans( core::iter::once(self.update_token.0.span) .chain(self.assignments.iter().map(Spanned::span)) .chain(self.update_predicate.iter().map(Spanned::span)) .chain(self.delete_predicate.iter().map(Spanned::span)), ) } } impl Spanned for OutputClause { fn span(&self) -> Span { match self { OutputClause::Output { output_token, select_items, into_table, } => union_spans( core::iter::once(output_token.0.span) .chain(into_table.iter().map(Spanned::span)) .chain(select_items.iter().map(Spanned::span)), ), OutputClause::Returning { returning_token, select_items, } => union_spans( core::iter::once(returning_token.0.span) .chain(select_items.iter().map(Spanned::span)), ), } } } impl Spanned for comments::CommentWithSpan { fn span(&self) -> Span { self.span } } #[cfg(test)] pub mod tests { use crate::ast::Value; use crate::dialect::{Dialect, GenericDialect, SnowflakeDialect}; use crate::parser::Parser; use crate::tokenizer::{Location, Span}; use super::*; struct SpanTest<'a>(Parser<'a>, &'a str); impl<'a> SpanTest<'a> { fn new(dialect: &'a dyn Dialect, sql: &'a str) -> Self { Self(Parser::new(dialect).try_with_sql(sql).unwrap(), sql) } // get the subsection of the source string that corresponds to the span // only works on single-line strings fn get_source(&self, span: Span) -> &'a str { // lines in spans are 1-indexed &self.1[(span.start.column as usize - 1)..(span.end.column - 1) as usize] } } #[test] fn test_join() { let dialect = &GenericDialect; let mut test = SpanTest::new( dialect, "SELECT id, name FROM users LEFT JOIN companies ON users.company_id = companies.id", ); let query = test.0.parse_select().unwrap(); let select_span = query.span(); assert_eq!( test.get_source(select_span), "SELECT id, name FROM users LEFT JOIN companies ON users.company_id = companies.id" ); let join_span = query.from[0].joins[0].span(); // 'LEFT JOIN' missing assert_eq!( test.get_source(join_span), "companies ON users.company_id = companies.id" ); } #[test] pub fn test_union() { let dialect = &GenericDialect; let mut test = SpanTest::new( dialect, "SELECT a FROM postgres.public.source UNION SELECT a FROM postgres.public.source", ); let query = test.0.parse_query().unwrap(); let select_span = query.span(); assert_eq!( test.get_source(select_span), "SELECT a FROM postgres.public.source UNION SELECT a FROM postgres.public.source" ); } #[test] pub fn test_subquery() { let dialect = &GenericDialect; let mut test = SpanTest::new( dialect, "SELECT a FROM (SELECT a FROM postgres.public.source) AS b", ); let query = test.0.parse_select().unwrap(); let select_span = query.span(); assert_eq!( test.get_source(select_span), "SELECT a FROM (SELECT a FROM postgres.public.source) AS b" ); let subquery_span = query.from[0].span(); // left paren missing assert_eq!( test.get_source(subquery_span), "SELECT a FROM postgres.public.source) AS b" ); } #[test] pub fn test_cte() { let dialect = &GenericDialect; let mut test = SpanTest::new(dialect, "WITH cte_outer AS (SELECT a FROM postgres.public.source), cte_ignored AS (SELECT a FROM cte_outer), cte_inner AS (SELECT a FROM cte_outer) SELECT a FROM cte_inner"); let query = test.0.parse_query().unwrap(); let select_span = query.span(); assert_eq!(test.get_source(select_span), "WITH cte_outer AS (SELECT a FROM postgres.public.source), cte_ignored AS (SELECT a FROM cte_outer), cte_inner AS (SELECT a FROM cte_outer) SELECT a FROM cte_inner"); } #[test] pub fn test_snowflake_lateral_flatten() { let dialect = &SnowflakeDialect; let mut test = SpanTest::new(dialect, "SELECT FLATTENED.VALUE:field::TEXT AS FIELD FROM SNOWFLAKE.SCHEMA.SOURCE AS S, LATERAL FLATTEN(INPUT => S.JSON_ARRAY) AS FLATTENED"); let query = test.0.parse_select().unwrap(); let select_span = query.span(); assert_eq!(test.get_source(select_span), "SELECT FLATTENED.VALUE:field::TEXT AS FIELD FROM SNOWFLAKE.SCHEMA.SOURCE AS S, LATERAL FLATTEN(INPUT => S.JSON_ARRAY) AS FLATTENED"); } #[test] pub fn test_wildcard_from_cte() { let dialect = &GenericDialect; let mut test = SpanTest::new( dialect, "WITH cte AS (SELECT a FROM postgres.public.source) SELECT cte.* FROM cte", ); let query = test.0.parse_query().unwrap(); let cte_span = query.clone().with.unwrap().cte_tables[0].span(); let cte_query_span = query.clone().with.unwrap().cte_tables[0].query.span(); let body_span = query.body.span(); // the WITH keyboard is part of the query assert_eq!( test.get_source(cte_span), "cte AS (SELECT a FROM postgres.public.source)" ); assert_eq!( test.get_source(cte_query_span), "SELECT a FROM postgres.public.source" ); assert_eq!(test.get_source(body_span), "SELECT cte.* FROM cte"); } #[test] fn test_case_expr_span() { let dialect = &GenericDialect; let mut test = SpanTest::new(dialect, "CASE 1 WHEN 2 THEN 3 ELSE 4 END"); let expr = test.0.parse_expr().unwrap(); let expr_span = expr.span(); assert_eq!( test.get_source(expr_span), "CASE 1 WHEN 2 THEN 3 ELSE 4 END" ); } #[test] fn test_placeholder_span() { let sql = "\nSELECT\n :fooBar"; let r = Parser::parse_sql(&GenericDialect, sql).unwrap(); assert_eq!(1, r.len()); match &r[0] { Statement::Query(q) => { let col = &q.body.as_select().unwrap().projection[0]; match col { SelectItem::UnnamedExpr(Expr::Value(ValueWithSpan { value: Value::Placeholder(s), span, })) => { assert_eq!(":fooBar", s); assert_eq!(&Span::new((3, 3).into(), (3, 10).into()), span); } _ => panic!("expected unnamed expression; got {col:?}"), } } stmt => panic!("expected query; got {stmt:?}"), } } #[test] fn test_alter_table_multiline_span() { let sql = r#"-- foo ALTER TABLE users ADD COLUMN foo varchar; -- hi there"#; let r = Parser::parse_sql(&crate::dialect::PostgreSqlDialect {}, sql).unwrap(); assert_eq!(1, r.len()); let stmt_span = r[0].span(); assert_eq!(stmt_span.start, (2, 13).into()); assert_eq!(stmt_span.end, (4, 11).into()); } #[test] fn test_update_statement_span() { let sql = r#"-- foo UPDATE foo /* bar */ SET bar = 3 WHERE quux > 42 ; "#; let r = Parser::parse_sql(&crate::dialect::GenericDialect, sql).unwrap(); assert_eq!(1, r.len()); let stmt_span = r[0].span(); assert_eq!(stmt_span.start, (2, 7).into()); assert_eq!(stmt_span.end, (5, 17).into()); } #[test] fn test_insert_statement_span() { let sql = r#" /* foo */ INSERT INTO FOO (X, Y, Z) SELECT 1, 2, 3 FROM DUAL ;"#; let r = Parser::parse_sql(&crate::dialect::GenericDialect, sql).unwrap(); assert_eq!(1, r.len()); let stmt_span = r[0].span(); assert_eq!(stmt_span.start, (2, 11).into()); assert_eq!(stmt_span.end, (4, 12).into()); } #[test] fn test_replace_statement_span() { let sql = r#" /* foo */ REPLACE INTO cities(name,population) SELECT name, population FROM cities WHERE id = 1 ;"#; let r = Parser::parse_sql(&crate::dialect::GenericDialect, sql).unwrap(); assert_eq!(1, r.len()); dbg!(&r[0]); let stmt_span = r[0].span(); assert_eq!(stmt_span.start, (2, 11).into()); assert_eq!(stmt_span.end, (9, 13).into()); } #[test] fn test_delete_statement_span() { let sql = r#"-- foo DELETE /* quux */ FROM foo WHERE foo.x = 42 ;"#; let r = Parser::parse_sql(&crate::dialect::GenericDialect, sql).unwrap(); assert_eq!(1, r.len()); let stmt_span = r[0].span(); assert_eq!(stmt_span.start, (2, 7).into()); assert_eq!(stmt_span.end, (4, 24).into()); } #[test] fn test_merge_statement_spans() { let sql = r#" -- plain merge statement; no RETURNING, no OUTPUT MERGE INTO target_table USING source_table ON target_table.id = source_table.oooid /* an inline comment */ WHEN NOT MATCHED THEN INSERT (ID, description) VALUES (source_table.id, source_table.description) -- another one WHEN MATCHED AND target_table.x = 'X' THEN UPDATE SET target_table.description = source_table.description WHEN MATCHED AND target_table.x != 'X' THEN DELETE WHEN NOT MATCHED AND 1 THEN INSERT (product, quantity) ROW "#; let r = Parser::parse_sql(&crate::dialect::GenericDialect, sql).unwrap(); assert_eq!(1, r.len()); // ~ assert the span of the whole statement let stmt_span = r[0].span(); assert_eq!(stmt_span.start, (4, 9).into()); assert_eq!(stmt_span.end, (16, 67).into()); // ~ individual tokens within the statement let Statement::Merge(Merge { merge_token, optimizer_hints: _, into: _, table: _, source: _, on: _, clauses, output, }) = &r[0] else { panic!("not a MERGE statement"); }; assert_eq!( merge_token.0.span, Span::new(Location::new(4, 9), Location::new(4, 14)) ); assert_eq!(clauses.len(), 4); // ~ the INSERT clause's TOKENs assert_eq!( clauses[0].when_token.0.span, Span::new(Location::new(7, 33), Location::new(7, 37)) ); if let MergeAction::Insert(MergeInsertExpr { insert_token, kind_token, .. }) = &clauses[0].action { assert_eq!( insert_token.0.span, Span::new(Location::new(8, 13), Location::new(8, 19)) ); assert_eq!( kind_token.0.span, Span::new(Location::new(9, 16), Location::new(9, 22)) ); } else { panic!("not a MERGE INSERT clause"); } // ~ the UPDATE token(s) assert_eq!( clauses[1].when_token.0.span, Span::new(Location::new(12, 17), Location::new(12, 21)) ); if let MergeAction::Update(MergeUpdateExpr { update_token, assignments: _, update_predicate: _, delete_predicate: _, }) = &clauses[1].action { assert_eq!( update_token.0.span, Span::new(Location::new(13, 13), Location::new(13, 19)) ); } else { panic!("not a MERGE UPDATE clause"); } // the DELETE token(s) assert_eq!( clauses[2].when_token.0.span, Span::new(Location::new(15, 15), Location::new(15, 19)) ); if let MergeAction::Delete { delete_token } = &clauses[2].action { assert_eq!( delete_token.0.span, Span::new(Location::new(15, 61), Location::new(15, 67)) ); } else { panic!("not a MERGE DELETE clause"); } // ~ an INSERT clause's ROW token assert_eq!( clauses[3].when_token.0.span, Span::new(Location::new(16, 9), Location::new(16, 13)) ); if let MergeAction::Insert(MergeInsertExpr { insert_token, kind_token, .. }) = &clauses[3].action { assert_eq!( insert_token.0.span, Span::new(Location::new(16, 37), Location::new(16, 43)) ); assert_eq!( kind_token.0.span, Span::new(Location::new(16, 64), Location::new(16, 67)) ); } else { panic!("not a MERGE INSERT clause"); } assert!(output.is_none()); } #[test] fn test_merge_statement_spans_with_returning() { let sql = r#" MERGE INTO wines AS w USING wine_stock_changes AS s ON s.winename = w.winename WHEN NOT MATCHED AND s.stock_delta > 0 THEN INSERT VALUES (s.winename, s.stock_delta) WHEN MATCHED AND w.stock + s.stock_delta > 0 THEN UPDATE SET stock = w.stock + s.stock_delta WHEN MATCHED THEN DELETE RETURNING merge_action(), w.* "#; let r = Parser::parse_sql(&crate::dialect::GenericDialect, sql).unwrap(); assert_eq!(1, r.len()); // ~ assert the span of the whole statement let stmt_span = r[0].span(); assert_eq!( stmt_span, Span::new(Location::new(2, 5), Location::new(8, 34)) ); // ~ individual tokens within the statement if let Statement::Merge(Merge { output, .. }) = &r[0] { if let Some(OutputClause::Returning { returning_token, .. }) = output { assert_eq!( returning_token.0.span, Span::new(Location::new(8, 5), Location::new(8, 14)) ); } else { panic!("unexpected MERGE output clause"); } } else { panic!("not a MERGE statement"); }; } #[test] fn test_merge_statement_spans_with_output() { let sql = r#"MERGE INTO a USING b ON a.id = b.id WHEN MATCHED THEN DELETE OUTPUT inserted.*"#; let r = Parser::parse_sql(&crate::dialect::GenericDialect, sql).unwrap(); assert_eq!(1, r.len()); // ~ assert the span of the whole statement let stmt_span = r[0].span(); assert_eq!( stmt_span, Span::new(Location::new(1, 1), Location::new(3, 32)) ); // ~ individual tokens within the statement if let Statement::Merge(Merge { output, .. }) = &r[0] { if let Some(OutputClause::Output { output_token, .. }) = output { assert_eq!( output_token.0.span, Span::new(Location::new(3, 15), Location::new(3, 21)) ); } else { panic!("unexpected MERGE output clause"); } } else { panic!("not a MERGE statement"); }; } #[test] fn test_merge_statement_spans_with_update_predicates() { let sql = r#" MERGE INTO a USING b ON a.id = b.id WHEN MATCHED THEN UPDATE set a.x = a.x + b.x WHERE b.x != 2 DELETE WHERE a.x <> 3"#; let r = Parser::parse_sql(&crate::dialect::GenericDialect, sql).unwrap(); assert_eq!(1, r.len()); // ~ assert the span of the whole statement let stmt_span = r[0].span(); assert_eq!( stmt_span, Span::new(Location::new(2, 8), Location::new(6, 36)) ); } #[test] fn test_merge_statement_spans_with_insert_predicate() { let sql = r#" MERGE INTO a USING b ON a.id = b.id WHEN NOT MATCHED THEN INSERT VALUES (b.x, b.y) WHERE b.x != 2 -- qed "#; let r = Parser::parse_sql(&crate::dialect::GenericDialect, sql).unwrap(); assert_eq!(1, r.len()); // ~ assert the span of the whole statement let stmt_span = r[0].span(); assert_eq!( stmt_span, Span::new(Location::new(2, 8), Location::new(4, 52)) ); } } apache-datafusion-sqlparser-rs-0.62.0/src/ast/table_constraints.rs000066400000000000000000000537761517524037000252770ustar00rootroot00000000000000// 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. //! SQL Abstract Syntax Tree (AST) types for table constraints use crate::ast::{ display_comma_separated, display_separated, ConstraintCharacteristics, ConstraintReferenceMatchKind, Expr, Ident, IndexColumn, IndexOption, IndexType, KeyOrIndexDisplay, NullsDistinctOption, ObjectName, ReferentialAction, }; use crate::tokenizer::Span; use core::fmt; #[cfg(not(feature = "std"))] use alloc::{boxed::Box, vec::Vec}; #[cfg(feature = "serde")] use serde::{Deserialize, Serialize}; #[cfg(feature = "visitor")] use sqlparser_derive::{Visit, VisitMut}; /// A table-level constraint, specified in a `CREATE TABLE` or an /// `ALTER TABLE ADD ` statement. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum TableConstraint { /// MySQL [definition][1] for `UNIQUE` constraints statements:\ /// * `[CONSTRAINT []] UNIQUE [] [index_type] () ` /// /// where: /// * [index_type][2] is `USING {BTREE | HASH}` /// * [index_options][3] is `{index_type | COMMENT 'string' | ... %currently unsupported stmts% } ...` /// * [index_type_display][4] is `[INDEX | KEY]` /// /// [1]: https://dev.mysql.com/doc/refman/8.3/en/create-table.html /// [2]: IndexType /// [3]: IndexOption /// [4]: KeyOrIndexDisplay Unique(UniqueConstraint), /// MySQL [definition][1] for `PRIMARY KEY` constraints statements:\ /// * `[CONSTRAINT []] PRIMARY KEY [index_name] [index_type] () ` /// /// Actually the specification have no `[index_name]` but the next query will complete successfully: /// ```sql /// CREATE TABLE unspec_table ( /// xid INT NOT NULL, /// CONSTRAINT p_name PRIMARY KEY index_name USING BTREE (xid) /// ); /// ``` /// /// where: /// * [index_type][2] is `USING {BTREE | HASH}` /// * [index_options][3] is `{index_type | COMMENT 'string' | ... %currently unsupported stmts% } ...` /// /// [1]: https://dev.mysql.com/doc/refman/8.3/en/create-table.html /// [2]: IndexType /// [3]: IndexOption PrimaryKey(PrimaryKeyConstraint), /// A referential integrity constraint (`[ CONSTRAINT ] FOREIGN KEY () /// REFERENCES () /// { [ON DELETE ] [ON UPDATE ] | /// [ON UPDATE ] [ON DELETE ] /// }`). ForeignKey(ForeignKeyConstraint), /// `[ CONSTRAINT ] CHECK () [[NOT] ENFORCED]` Check(CheckConstraint), /// MySQLs [index definition][1] for index creation. Not present on ANSI so, for now, the usage /// is restricted to MySQL, as no other dialects that support this syntax were found. /// /// `{INDEX | KEY} [index_name] [index_type] (key_part,...) [index_option]...` /// /// [1]: https://dev.mysql.com/doc/refman/8.0/en/create-table.html Index(IndexConstraint), /// MySQLs [fulltext][1] definition. Since the [`SPATIAL`][2] definition is exactly the same, /// and MySQL displays both the same way, it is part of this definition as well. /// /// Supported syntax: /// /// ```markdown /// {FULLTEXT | SPATIAL} [INDEX | KEY] [index_name] (key_part,...) /// /// key_part: col_name /// ``` /// /// [1]: https://dev.mysql.com/doc/refman/8.0/en/fulltext-natural-language.html /// [2]: https://dev.mysql.com/doc/refman/8.0/en/spatial-types.html FulltextOrSpatial(FullTextOrSpatialConstraint), /// PostgreSQL [definition][1] for promoting an existing unique index to a /// `PRIMARY KEY` constraint: /// /// `[ CONSTRAINT constraint_name ] PRIMARY KEY USING INDEX index_name /// [ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]` /// /// [1]: https://www.postgresql.org/docs/current/sql-altertable.html PrimaryKeyUsingIndex(ConstraintUsingIndex), /// PostgreSQL [definition][1] for promoting an existing unique index to a /// `UNIQUE` constraint: /// /// `[ CONSTRAINT constraint_name ] UNIQUE USING INDEX index_name /// [ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]` /// /// [1]: https://www.postgresql.org/docs/current/sql-altertable.html UniqueUsingIndex(ConstraintUsingIndex), } impl From for TableConstraint { fn from(constraint: UniqueConstraint) -> Self { TableConstraint::Unique(constraint) } } impl From for TableConstraint { fn from(constraint: PrimaryKeyConstraint) -> Self { TableConstraint::PrimaryKey(constraint) } } impl From for TableConstraint { fn from(constraint: ForeignKeyConstraint) -> Self { TableConstraint::ForeignKey(constraint) } } impl From for TableConstraint { fn from(constraint: CheckConstraint) -> Self { TableConstraint::Check(constraint) } } impl From for TableConstraint { fn from(constraint: IndexConstraint) -> Self { TableConstraint::Index(constraint) } } impl From for TableConstraint { fn from(constraint: FullTextOrSpatialConstraint) -> Self { TableConstraint::FulltextOrSpatial(constraint) } } impl fmt::Display for TableConstraint { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { TableConstraint::Unique(constraint) => constraint.fmt(f), TableConstraint::PrimaryKey(constraint) => constraint.fmt(f), TableConstraint::ForeignKey(constraint) => constraint.fmt(f), TableConstraint::Check(constraint) => constraint.fmt(f), TableConstraint::Index(constraint) => constraint.fmt(f), TableConstraint::FulltextOrSpatial(constraint) => constraint.fmt(f), TableConstraint::PrimaryKeyUsingIndex(c) => c.fmt_with_keyword(f, "PRIMARY KEY"), TableConstraint::UniqueUsingIndex(c) => c.fmt_with_keyword(f, "UNIQUE"), } } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// A `CHECK` constraint (`[ CONSTRAINT ] CHECK () [[NOT] ENFORCED]`). pub struct CheckConstraint { /// Optional constraint name. pub name: Option, /// The boolean expression the CHECK constraint enforces. pub expr: Box, /// MySQL-specific `ENFORCED` / `NOT ENFORCED` flag. /// pub enforced: Option, } impl fmt::Display for CheckConstraint { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { use crate::ast::ddl::display_constraint_name; write!( f, "{}CHECK ({})", display_constraint_name(&self.name), self.expr )?; if let Some(b) = self.enforced { write!(f, " {}", if b { "ENFORCED" } else { "NOT ENFORCED" }) } else { Ok(()) } } } impl crate::ast::Spanned for CheckConstraint { fn span(&self) -> Span { self.expr .span() .union_opt(&self.name.as_ref().map(|i| i.span)) } } /// A referential integrity constraint (`[ CONSTRAINT ] FOREIGN KEY () /// REFERENCES () [ MATCH { FULL | PARTIAL | SIMPLE } ] /// { [ON DELETE ] [ON UPDATE ] | /// [ON UPDATE ] [ON DELETE ] /// }`). #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct ForeignKeyConstraint { /// Optional constraint name. pub name: Option, /// MySQL-specific index name associated with the foreign key. /// pub index_name: Option, /// Columns in the local table that participate in the foreign key. pub columns: Vec, /// Referenced foreign table name. pub foreign_table: ObjectName, /// Columns in the referenced table. pub referred_columns: Vec, /// Action to perform `ON DELETE`. pub on_delete: Option, /// Action to perform `ON UPDATE`. pub on_update: Option, /// Optional `MATCH` kind (FULL | PARTIAL | SIMPLE). pub match_kind: Option, /// Optional characteristics (e.g., `DEFERRABLE`). pub characteristics: Option, } impl fmt::Display for ForeignKeyConstraint { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { use crate::ast::ddl::{display_constraint_name, display_option_spaced}; write!( f, "{}FOREIGN KEY{} ({}) REFERENCES {}", display_constraint_name(&self.name), display_option_spaced(&self.index_name), display_comma_separated(&self.columns), self.foreign_table, )?; if !self.referred_columns.is_empty() { write!(f, "({})", display_comma_separated(&self.referred_columns))?; } if let Some(match_kind) = &self.match_kind { write!(f, " {match_kind}")?; } if let Some(action) = &self.on_delete { write!(f, " ON DELETE {action}")?; } if let Some(action) = &self.on_update { write!(f, " ON UPDATE {action}")?; } if let Some(characteristics) = &self.characteristics { write!(f, " {characteristics}")?; } Ok(()) } } impl crate::ast::Spanned for ForeignKeyConstraint { fn span(&self) -> Span { fn union_spans>(iter: I) -> Span { Span::union_iter(iter) } union_spans( self.name .iter() .map(|i| i.span) .chain(self.index_name.iter().map(|i| i.span)) .chain(self.columns.iter().map(|i| i.span)) .chain(core::iter::once(self.foreign_table.span())) .chain(self.referred_columns.iter().map(|i| i.span)) .chain(self.on_delete.iter().map(|i| i.span())) .chain(self.on_update.iter().map(|i| i.span())) .chain(self.characteristics.iter().map(|i| i.span())), ) } } /// MySQLs [fulltext][1] definition. Since the [`SPATIAL`][2] definition is exactly the same, /// and MySQL displays both the same way, it is part of this definition as well. /// /// Supported syntax: /// /// ```markdown /// {FULLTEXT | SPATIAL} [INDEX | KEY] [index_name] (key_part,...) /// /// key_part: col_name /// ``` /// /// [1]: https://dev.mysql.com/doc/refman/8.0/en/fulltext-natural-language.html /// [2]: https://dev.mysql.com/doc/refman/8.0/en/spatial-types.html #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct FullTextOrSpatialConstraint { /// Whether this is a `FULLTEXT` (true) or `SPATIAL` (false) definition. pub fulltext: bool, /// Whether the type is followed by the keyword `KEY`, `INDEX`, or no keyword at all. pub index_type_display: KeyOrIndexDisplay, /// Optional index name. pub opt_index_name: Option, /// Referred column identifier list. pub columns: Vec, } impl fmt::Display for FullTextOrSpatialConstraint { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { if self.fulltext { write!(f, "FULLTEXT")?; } else { write!(f, "SPATIAL")?; } write!(f, "{:>}", self.index_type_display)?; if let Some(name) = &self.opt_index_name { write!(f, " {name}")?; } write!(f, " ({})", display_comma_separated(&self.columns))?; Ok(()) } } impl crate::ast::Spanned for FullTextOrSpatialConstraint { fn span(&self) -> Span { fn union_spans>(iter: I) -> Span { Span::union_iter(iter) } union_spans( self.opt_index_name .iter() .map(|i| i.span) .chain(self.columns.iter().map(|i| i.span())), ) } } /// MySQLs [index definition][1] for index creation. Not present on ANSI so, for now, the usage /// is restricted to MySQL, as no other dialects that support this syntax were found. /// /// `{INDEX | KEY} [index_name] [index_type] (key_part,...) [index_option]...` /// /// [1]: https://dev.mysql.com/doc/refman/8.0/en/create-table.html #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct IndexConstraint { /// Whether this index starts with KEY (true) or INDEX (false), to maintain the same syntax. pub display_as_key: bool, /// Index name. pub name: Option, /// Optional [index type][1]. /// /// [1]: IndexType pub index_type: Option, /// Referred column identifier list. pub columns: Vec, /// Optional index options such as `USING`; see [`IndexOption`]. /// Options applied to the index (e.g., `COMMENT`, `WITH` options). pub index_options: Vec, } impl fmt::Display for IndexConstraint { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{}", if self.display_as_key { "KEY" } else { "INDEX" })?; if let Some(name) = &self.name { write!(f, " {name}")?; } if let Some(index_type) = &self.index_type { write!(f, " USING {index_type}")?; } write!(f, " ({})", display_comma_separated(&self.columns))?; if !self.index_options.is_empty() { write!(f, " {}", display_comma_separated(&self.index_options))?; } Ok(()) } } impl crate::ast::Spanned for IndexConstraint { fn span(&self) -> Span { fn union_spans>(iter: I) -> Span { Span::union_iter(iter) } union_spans( self.name .iter() .map(|i| i.span) .chain(self.columns.iter().map(|i| i.span())), ) } } /// MySQL [definition][1] for `PRIMARY KEY` constraints statements: /// * `[CONSTRAINT []] PRIMARY KEY [index_name] [index_type] () ` /// /// Actually the specification have no `[index_name]` but the next query will complete successfully: /// ```sql /// CREATE TABLE unspec_table ( /// xid INT NOT NULL, /// CONSTRAINT p_name PRIMARY KEY index_name USING BTREE (xid) /// ); /// ``` /// /// where: /// * [index_type][2] is `USING {BTREE | HASH}` /// * [index_options][3] is `{index_type | COMMENT 'string' | ... %currently unsupported stmts% } ...` /// /// [1]: https://dev.mysql.com/doc/refman/8.3/en/create-table.html /// [2]: IndexType /// [3]: IndexOption #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct PrimaryKeyConstraint { /// Constraint name. /// /// Can be not the same as `index_name` pub name: Option, /// Index name pub index_name: Option, /// Optional `USING` of [index type][1] statement before columns. /// /// [1]: IndexType pub index_type: Option, /// Identifiers of the columns that form the primary key. pub columns: Vec, /// Optional index options such as `USING`. pub index_options: Vec, /// Optional characteristics like `DEFERRABLE`. pub characteristics: Option, } impl fmt::Display for PrimaryKeyConstraint { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { use crate::ast::ddl::{display_constraint_name, display_option, display_option_spaced}; write!( f, "{}PRIMARY KEY{}{} ({})", display_constraint_name(&self.name), display_option_spaced(&self.index_name), display_option(" USING ", "", &self.index_type), display_comma_separated(&self.columns), )?; if !self.index_options.is_empty() { write!(f, " {}", display_separated(&self.index_options, " "))?; } write!(f, "{}", display_option_spaced(&self.characteristics))?; Ok(()) } } impl crate::ast::Spanned for PrimaryKeyConstraint { fn span(&self) -> Span { fn union_spans>(iter: I) -> Span { Span::union_iter(iter) } union_spans( self.name .iter() .map(|i| i.span) .chain(self.index_name.iter().map(|i| i.span)) .chain(self.columns.iter().map(|i| i.span())) .chain(self.characteristics.iter().map(|i| i.span())), ) } } #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// Unique constraint definition. pub struct UniqueConstraint { /// Constraint name. /// /// Can be not the same as `index_name` pub name: Option, /// Index name pub index_name: Option, /// Whether the type is followed by the keyword `KEY`, `INDEX`, or no keyword at all. pub index_type_display: KeyOrIndexDisplay, /// Optional `USING` of [index type][1] statement before columns. /// /// [1]: IndexType pub index_type: Option, /// Identifiers of the columns that are unique. pub columns: Vec, /// Optional index options such as `USING`. pub index_options: Vec, /// Optional characteristics like `DEFERRABLE`. pub characteristics: Option, /// Optional Postgres nulls handling: `[ NULLS [ NOT ] DISTINCT ]` pub nulls_distinct: NullsDistinctOption, } impl fmt::Display for UniqueConstraint { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { use crate::ast::ddl::{display_constraint_name, display_option, display_option_spaced}; write!( f, "{}UNIQUE{}{:>}{}{} ({})", display_constraint_name(&self.name), self.nulls_distinct, self.index_type_display, display_option_spaced(&self.index_name), display_option(" USING ", "", &self.index_type), display_comma_separated(&self.columns), )?; if !self.index_options.is_empty() { write!(f, " {}", display_separated(&self.index_options, " "))?; } write!(f, "{}", display_option_spaced(&self.characteristics))?; Ok(()) } } impl crate::ast::Spanned for UniqueConstraint { fn span(&self) -> Span { fn union_spans>(iter: I) -> Span { Span::union_iter(iter) } union_spans( self.name .iter() .map(|i| i.span) .chain(self.index_name.iter().map(|i| i.span)) .chain(self.columns.iter().map(|i| i.span())) .chain(self.characteristics.iter().map(|i| i.span())), ) } } /// PostgreSQL constraint that promotes an existing unique index to a table constraint. /// /// `[ CONSTRAINT constraint_name ] { UNIQUE | PRIMARY KEY } USING INDEX index_name /// [ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]` /// /// See #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct ConstraintUsingIndex { /// Optional constraint name. pub name: Option, /// The name of the existing unique index to promote. pub index_name: Ident, /// Optional characteristics like `DEFERRABLE`. pub characteristics: Option, } impl ConstraintUsingIndex { /// Format as `[CONSTRAINT name] USING INDEX index_name [characteristics]`. pub fn fmt_with_keyword(&self, f: &mut fmt::Formatter, keyword: &str) -> fmt::Result { use crate::ast::ddl::{display_constraint_name, display_option_spaced}; write!( f, "{}{} USING INDEX {}", display_constraint_name(&self.name), keyword, self.index_name, )?; write!(f, "{}", display_option_spaced(&self.characteristics))?; Ok(()) } } impl crate::ast::Spanned for ConstraintUsingIndex { fn span(&self) -> Span { let start = self .name .as_ref() .map(|i| i.span) .unwrap_or(self.index_name.span); let end = self .characteristics .as_ref() .map(|c| c.span()) .unwrap_or(self.index_name.span); start.union(&end) } } apache-datafusion-sqlparser-rs-0.62.0/src/ast/trigger.rs000066400000000000000000000155521517524037000232120ustar00rootroot00000000000000// 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. //! SQL Abstract Syntax Tree (AST) for triggers. use super::*; /// This specifies whether the trigger function should be fired once for every row affected by the trigger event, or just once per SQL statement. #[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum TriggerObject { /// The trigger fires once for each row affected by the triggering event Row, /// The trigger fires once for the triggering SQL statement Statement, } impl fmt::Display for TriggerObject { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { TriggerObject::Row => write!(f, "ROW"), TriggerObject::Statement => write!(f, "STATEMENT"), } } } #[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// This clause indicates whether the following relation name is for the before-image transition relation or the after-image transition relation pub enum TriggerReferencingType { /// The transition relation containing the old rows affected by the triggering statement OldTable, /// The transition relation containing the new rows affected by the triggering statement NewTable, } impl fmt::Display for TriggerReferencingType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { TriggerReferencingType::OldTable => write!(f, "OLD TABLE"), TriggerReferencingType::NewTable => write!(f, "NEW TABLE"), } } } /// This keyword immediately precedes the declaration of one or two relation names that provide access to the transition relations of the triggering statement #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct TriggerReferencing { /// The referencing type (`OLD TABLE` or `NEW TABLE`). pub refer_type: TriggerReferencingType, /// True if the `AS` keyword is present in the referencing clause. pub is_as: bool, /// The transition relation name provided by the referencing clause. pub transition_relation_name: ObjectName, } impl fmt::Display for TriggerReferencing { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "{refer_type}{is_as} {relation_name}", refer_type = self.refer_type, is_as = if self.is_as { " AS" } else { "" }, relation_name = self.transition_relation_name ) } } /// Used to describe trigger events #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum TriggerEvent { /// Trigger on INSERT event Insert, /// Trigger on UPDATE event, with optional list of columns Update(Vec), /// Trigger on DELETE event Delete, /// Trigger on TRUNCATE event Truncate, } impl fmt::Display for TriggerEvent { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { TriggerEvent::Insert => write!(f, "INSERT"), TriggerEvent::Update(columns) => { write!(f, "UPDATE")?; if !columns.is_empty() { write!(f, " OF")?; write!(f, " {}", display_comma_separated(columns))?; } Ok(()) } TriggerEvent::Delete => write!(f, "DELETE"), TriggerEvent::Truncate => write!(f, "TRUNCATE"), } } } /// Trigger period #[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum TriggerPeriod { /// The trigger fires once for each row affected by the triggering event For, /// The trigger fires once for the triggering SQL statement After, /// The trigger fires before the triggering event Before, /// The trigger fires instead of the triggering event InsteadOf, } 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"), } } } /// Types of trigger body execution body. #[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum TriggerExecBodyType { /// Execute a function Function, /// Execute a procedure Procedure, } impl fmt::Display for TriggerExecBodyType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { TriggerExecBodyType::Function => write!(f, "FUNCTION"), TriggerExecBodyType::Procedure => write!(f, "PROCEDURE"), } } } /// This keyword immediately precedes the declaration of one or two relation names that provide access to the transition relations of the triggering statement #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct TriggerExecBody { /// Whether the body is a `FUNCTION` or `PROCEDURE` invocation. pub exec_type: TriggerExecBodyType, /// Description of the function/procedure to execute. pub func_desc: FunctionDesc, } impl fmt::Display for TriggerExecBody { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "{exec_type} {func_desc}", exec_type = self.exec_type, func_desc = self.func_desc ) } } apache-datafusion-sqlparser-rs-0.62.0/src/ast/value.rs000066400000000000000000000646151517524037000226670ustar00rootroot00000000000000// 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. #[cfg(not(feature = "std"))] use alloc::string::String; use core::{ fmt, ops::{Deref, DerefMut}, }; #[cfg(feature = "bigdecimal")] use bigdecimal::BigDecimal; #[cfg(feature = "serde")] use serde::{Deserialize, Serialize}; use crate::{ast::Ident, tokenizer::Span}; #[cfg(feature = "visitor")] use sqlparser_derive::{Visit, VisitMut}; /// Wraps a primitive SQL [`Value`] with its [`Span`] location /// /// # Example: create a `ValueWithSpan` from a `Value` /// ``` /// # use sqlparser::ast::{Value, ValueWithSpan}; /// # use sqlparser::tokenizer::{Location, Span}; /// let value = Value::SingleQuotedString(String::from("endpoint")); /// // from line 1, column 1 to line 1, column 7 /// let span = Span::new(Location::new(1, 1), Location::new(1, 7)); /// let value_with_span = value.with_span(span); /// ``` /// /// # Example: create a `ValueWithSpan` from a `Value` with an empty span /// /// You can call [`Value::with_empty_span`] to create a `ValueWithSpan` with an empty span /// ``` /// # use sqlparser::ast::{Value, ValueWithSpan}; /// # use sqlparser::tokenizer::{Location, Span}; /// let value = Value::SingleQuotedString(String::from("endpoint")); /// let value_with_span = value.with_empty_span(); /// assert_eq!(value_with_span.span, Span::empty()); /// ``` /// /// You can also use the [`From`] trait to convert `ValueWithSpan` to/from `Value`s /// ``` /// # use sqlparser::ast::{Value, ValueWithSpan}; /// # use sqlparser::tokenizer::{Location, Span}; /// let value = Value::SingleQuotedString(String::from("endpoint")); /// // converting `Value` to `ValueWithSpan` results in an empty span /// let value_with_span: ValueWithSpan = value.into(); /// assert_eq!(value_with_span.span, Span::empty()); /// // convert back to `Value` /// let value: Value = value_with_span.into(); /// ``` /// A `Value` paired with its source `Span` location. #[derive(Debug, Clone, Eq)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr( feature = "visitor", derive(Visit, VisitMut), visit(with = "visit_value") )] pub struct ValueWithSpan { /// The wrapped `Value`. pub value: Value, /// The source `Span` covering the token(s) that produced the 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 { Some(Ord::cmp(self, other)) } } impl core::hash::Hash for ValueWithSpan { fn hash(&self, state: &mut H) { self.value.hash(state); } } impl From for ValueWithSpan { fn from(value: Value) -> Self { value.with_empty_span() } } impl From for Value { fn from(value: ValueWithSpan) -> Self { value.value } } impl Deref for ValueWithSpan { type Target = Value; fn deref(&self) -> &Self::Target { &self.value } } impl DerefMut for ValueWithSpan { fn deref_mut(&mut self) -> &mut Self::Target { &mut self.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))] pub enum Value { /// Numeric literal #[cfg(not(feature = "bigdecimal"))] Number(String, bool), #[cfg(feature = "bigdecimal")] /// HINT: use `test_utils::number` to make an instance of /// Value::Number This might help if you your tests pass locally /// but fail on CI with the `--all-features` flag enabled /// Numeric literal (uses `BigDecimal` when the `bigdecimal` feature is enabled). Number(BigDecimal, bool), /// 'string value' SingleQuotedString(String), /// Dollar-quoted string literal, e.g. `$$...$$` or `$tag$...$tag$` (Postgres syntax). DollarQuotedString(DollarQuotedString), /// Triple single quoted strings: Example '''abc''' /// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#quoted_literals) TripleSingleQuotedString(String), /// Triple double quoted strings: Example """abc""" /// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#quoted_literals) TripleDoubleQuotedString(String), /// e'string value' (postgres extension) /// See [Postgres docs](https://www.postgresql.org/docs/8.3/sql-syntax-lexical.html#SQL-SYNTAX-STRINGS) /// for more details. EscapedStringLiteral(String), /// u&'string value' (postgres extension) /// See [Postgres docs](https://www.postgresql.org/docs/current/sql-syntax-lexical.html#SQL-SYNTAX-STRINGS-UESCAPE) /// for more details. UnicodeStringLiteral(String), /// B'string value' SingleQuotedByteStringLiteral(String), /// B"string value" DoubleQuotedByteStringLiteral(String), /// Triple single quoted literal with byte string prefix. Example `B'''abc'''` /// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#quoted_literals) TripleSingleQuotedByteStringLiteral(String), /// Triple double quoted literal with byte string prefix. Example `B"""abc"""` /// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#quoted_literals) TripleDoubleQuotedByteStringLiteral(String), /// Single quoted literal with raw string prefix. Example `R'abc'` /// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#quoted_literals) SingleQuotedRawStringLiteral(String), /// Double quoted literal with raw string prefix. Example `R"abc"` /// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#quoted_literals) DoubleQuotedRawStringLiteral(String), /// Triple single quoted literal with raw string prefix. Example `R'''abc'''` /// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#quoted_literals) TripleSingleQuotedRawStringLiteral(String), /// Triple double quoted literal with raw string prefix. Example `R"""abc"""` /// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#quoted_literals) TripleDoubleQuotedRawStringLiteral(String), /// N'string value' NationalStringLiteral(String), /// Quote delimited literal. Examples `Q'{ab'c}'`, `Q'|ab'c|'`, `Q'|ab|c|'` /// [Oracle](https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/Literals.html#GUID-1824CBAA-6E16-4921-B2A6-112FB02248DA) QuoteDelimitedStringLiteral(QuoteDelimitedString), /// "National" quote delimited literal. Examples `Q'{ab'c}'`, `Q'|ab'c|'`, `Q'|ab|c|'` /// [Oracle](https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/Literals.html#GUID-1824CBAA-6E16-4921-B2A6-112FB02248DA) NationalQuoteDelimitedStringLiteral(QuoteDelimitedString), /// X'hex value' HexStringLiteral(String), /// Double quoted string literal, e.g. `"abc"`. DoubleQuotedString(String), /// Boolean value true or false Boolean(bool), /// `NULL` value Null, /// `?` or `$` Prepared statement arg placeholder 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 { 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 { 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), Value::QuoteDelimitedStringLiteral(s) => Some(s.value), Value::NationalQuoteDelimitedStringLiteral(s) => Some(s.value), _ => None, } } /// Attach the provided `span` to this `Value` and return `ValueWithSpan`. pub fn with_span(self, span: Span) -> ValueWithSpan { ValueWithSpan { value: self, span } } /// Convenience for attaching an empty span to this `Value`. 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 { Value::Number(v, l) => write!(f, "{}{long}", v, long = if *l { "L" } else { "" }), Value::DoubleQuotedString(v) => write!(f, "\"{}\"", escape_double_quote_string(v)), Value::SingleQuotedString(v) => write!(f, "'{}'", escape_single_quote_string(v)), Value::TripleSingleQuotedString(v) => { write!(f, "'''{v}'''") } Value::TripleDoubleQuotedString(v) => { write!(f, r#""""{v}""""#) } Value::DollarQuotedString(v) => write!(f, "{v}"), Value::EscapedStringLiteral(v) => write!(f, "E'{}'", escape_escaped_string(v)), Value::UnicodeStringLiteral(v) => write!(f, "U&'{}'", escape_unicode_string(v)), Value::NationalStringLiteral(v) => write!(f, "N'{v}'"), Value::QuoteDelimitedStringLiteral(v) => v.fmt(f), Value::NationalQuoteDelimitedStringLiteral(v) => write!(f, "N{v}"), Value::HexStringLiteral(v) => write!(f, "X'{v}'"), Value::Boolean(v) => write!(f, "{v}"), Value::SingleQuotedByteStringLiteral(v) => write!(f, "B'{v}'"), Value::DoubleQuotedByteStringLiteral(v) => write!(f, "B\"{v}\""), Value::TripleSingleQuotedByteStringLiteral(v) => write!(f, "B'''{v}'''"), Value::TripleDoubleQuotedByteStringLiteral(v) => write!(f, r#"B"""{v}""""#), Value::SingleQuotedRawStringLiteral(v) => write!(f, "R'{v}'"), Value::DoubleQuotedRawStringLiteral(v) => write!(f, "R\"{v}\""), Value::TripleSingleQuotedRawStringLiteral(v) => write!(f, "R'''{v}'''"), Value::TripleDoubleQuotedRawStringLiteral(v) => write!(f, r#"R"""{v}""""#), Value::Null => write!(f, "NULL"), Value::Placeholder(v) => write!(f, "{v}"), } } } /// A dollar-quoted string literal, e.g. `$$...$$` or `$tag$...$tag$`. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct DollarQuotedString { /// Inner string contents. pub value: String, /// Optional tag used in the opening/closing delimiter. pub tag: Option, } impl fmt::Display for DollarQuotedString { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match &self.tag { Some(tag) => { write!(f, "${}${}${}$", tag, self.value, tag) } None => { write!(f, "$${}$$", self.value) } } } } /// A quote delimited string literal, e.g. `Q'_abc_'`. /// /// See [Value::QuoteDelimitedStringLiteral] and/or /// [Value::NationalQuoteDelimitedStringLiteral]. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct QuoteDelimitedString { /// the quote start character; i.e. the character _after_ the opening `Q'` pub start_quote: char, /// the string literal value itself pub value: String, /// the quote end character; i.e. the character _before_ the closing `'` pub end_quote: char, } impl fmt::Display for QuoteDelimitedString { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "Q'{}{}{}'", self.start_quote, self.value, self.end_quote) } } /// Represents the date/time fields used by functions like `EXTRACT`. /// /// Each variant corresponds to a supported date/time part (for example /// `YEAR`, `MONTH`, `DAY`, etc.). The `Custom` variant allows arbitrary /// identifiers (e.g. dialect-specific abbreviations). #[derive(Debug, Clone, PartialEq, Eq, Ord, PartialOrd, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum DateTimeField { /// `YEAR` Year, /// `YEARS` (plural form) Years, /// `MONTH` Month, /// `MONTHS` (plural form) Months, /// `WEEK`, optionally followed by a weekday, e.g. `WEEK(MONDAY)`. /// /// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/date_functions#extract) Week(Option), /// `WEEKS` (plural form) Weeks, /// `DAY` Day, /// `DAYOFWEEK` DayOfWeek, /// `DAYOFYEAR` DayOfYear, /// `DAYS` (plural form) Days, /// `DATE` Date, /// `DATETIME` Datetime, /// `HOUR` Hour, /// `HOURS` (plural form) Hours, /// `MINUTE` Minute, /// `MINUTES` (plural form) Minutes, /// `SECOND` Second, /// `SECONDS` (plural form) Seconds, /// `CENTURY` Century, /// `DECADE` Decade, /// `DOW` (day of week short form) Dow, /// `DOY` (day of year short form) Doy, /// `EPOCH` Epoch, /// `ISODOW` Isodow, /// `ISOYEAR` Isoyear, /// `ISOWEEK` IsoWeek, /// `JULIAN` Julian, /// `MICROSECOND` Microsecond, /// `MICROSECONDS` (plural form) Microseconds, /// `MILLENIUM` (alternate spelling) Millenium, /// `MILLENNIUM` (alternate spelling) Millennium, /// `MILLISECOND` Millisecond, /// `MILLISECONDS` (plural form) Milliseconds, /// `NANOSECOND` Nanosecond, /// `NANOSECONDS` (plural form) Nanoseconds, /// `QUARTER` Quarter, /// `TIME` Time, /// `TIMEZONE` Timezone, /// `TIMEZONE_ABBR` TimezoneAbbr, /// `TIMEZONE_HOUR` TimezoneHour, /// `TIMEZONE_MINUTE` TimezoneMinute, /// `TIMEZONE_REGION` TimezoneRegion, /// `NODATETIME` indicates no date/time part NoDateTime, /// Arbitrary abbreviation or custom date-time part. /// /// ```sql /// EXTRACT(q FROM CURRENT_TIMESTAMP) /// ``` /// [Snowflake](https://docs.snowflake.com/en/sql-reference/functions-date-time#supported-date-and-time-parts) Custom(Ident), } 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 { write!(f, "({week_day})")? } 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"), DateTimeField::Doy => write!(f, "DOY"), DateTimeField::Epoch => write!(f, "EPOCH"), DateTimeField::Isodow => write!(f, "ISODOW"), DateTimeField::Isoyear => write!(f, "ISOYEAR"), DateTimeField::IsoWeek => write!(f, "ISOWEEK"), DateTimeField::Julian => write!(f, "JULIAN"), DateTimeField::Microsecond => write!(f, "MICROSECOND"), DateTimeField::Microseconds => write!(f, "MICROSECONDS"), DateTimeField::Millenium => write!(f, "MILLENIUM"), DateTimeField::Millennium => write!(f, "MILLENNIUM"), DateTimeField::Millisecond => write!(f, "MILLISECOND"), DateTimeField::Milliseconds => write!(f, "MILLISECONDS"), DateTimeField::Nanosecond => write!(f, "NANOSECOND"), DateTimeField::Nanoseconds => write!(f, "NANOSECONDS"), DateTimeField::Quarter => write!(f, "QUARTER"), DateTimeField::Time => write!(f, "TIME"), DateTimeField::Timezone => write!(f, "TIMEZONE"), DateTimeField::TimezoneAbbr => write!(f, "TIMEZONE_ABBR"), DateTimeField::TimezoneHour => write!(f, "TIMEZONE_HOUR"), DateTimeField::TimezoneMinute => write!(f, "TIMEZONE_MINUTE"), DateTimeField::TimezoneRegion => write!(f, "TIMEZONE_REGION"), DateTimeField::NoDateTime => write!(f, "NODATETIME"), DateTimeField::Custom(custom) => write!(f, "{custom}"), } } } #[derive(Debug, Clone, Copy, 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<'_> { 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 // strings without knowing if the strings are already escaped // or not. // // If the quote symbol in the string is repeated twice, OR, if // the quote symbol is after backslash, display all the chars // without any escape. However, if the quote symbol is used // just between usual chars, `fmt()` should display it twice." // // The following table has examples // // | original query | mode | AST Node | serialized | // | ------------- | --------- | -------------------------------------------------- | ------------ | // | `"A""B""A"` | no-escape | `DoubleQuotedString(String::from("A\"\"B\"\"A"))` | `"A""B""A"` | // | `"A""B""A"` | default | `DoubleQuotedString(String::from("A\"B\"A"))` | `"A""B""A"` | // | `"A\"B\"A"` | no-escape | `DoubleQuotedString(String::from("A\\\"B\\\"A"))` | `"A\"B\"A"` | // | `"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() { match ch { char if char == quote => { if previous_char == '\\' { // the quote is already escaped with a backslash, skip 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; } } } _ => { peekable_chars.next(); } } previous_char = ch; } f.write_str(&self.string[start_idx..])?; Ok(()) } } /// Return a helper which formats `string` for inclusion inside a quoted /// literal that uses `quote` as the delimiter. pub fn escape_quoted_string(string: &str, quote: char) -> EscapeQuotedString<'_> { EscapeQuotedString { string, quote } } /// Convenience wrapper for escaping strings for single-quoted literals (`'`). pub fn escape_single_quote_string(s: &str) -> EscapeQuotedString<'_> { escape_quoted_string(s, '\'') } /// Convenience wrapper for escaping strings for double-quoted literals (`").` pub fn escape_double_quote_string(s: &str) -> EscapeQuotedString<'_> { escape_quoted_string(s, '\"') } pub struct EscapeEscapedStringLiteral<'a>(&'a str); impl fmt::Display for EscapeEscapedStringLiteral<'_> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { for c in self.0.chars() { match c { '\'' => { write!(f, r#"\'"#)?; } '\\' => { write!(f, r#"\\"#)?; } '\n' => { write!(f, r#"\n"#)?; } '\t' => { write!(f, r#"\t"#)?; } '\r' => { write!(f, r#"\r"#)?; } _ => { write!(f, "{c}")?; } } } Ok(()) } } /// Return a helper which escapes characters for string literals that use /// PostgreSQL-style escaped string literals (e.g. `E'...')`. pub fn escape_escaped_string(s: &str) -> EscapeEscapedStringLiteral<'_> { EscapeEscapedStringLiteral(s) } pub struct EscapeUnicodeStringLiteral<'a>(&'a str); impl fmt::Display for EscapeUnicodeStringLiteral<'_> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { for c in self.0.chars() { match c { '\'' => { write!(f, "''")?; } '\\' => { write!(f, r#"\\"#)?; } x if x.is_ascii() => { 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}")?; } else { write!(f, "\\+{codepoint:06X}")?; } } } } Ok(()) } } /// Return a helper which escapes non-ASCII characters using `\XXXX` or /// `\+XXXXXX` Unicode escape formats (used for `U&'...'` style literals). pub fn escape_unicode_string(s: &str) -> EscapeUnicodeStringLiteral<'_> { EscapeUnicodeStringLiteral(s) } /// The side on which `TRIM` should be applied. /// /// Corresponds to `TRIM(BOTH|LEADING|TRAILING)` SQL syntax. #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum TrimWhereField { /// `BOTH` (trim from both ends) Both, /// `LEADING` (trim from start) Leading, /// `TRAILING` (trim from end) Trailing, } impl fmt::Display for TrimWhereField { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { use TrimWhereField::*; f.write_str(match self { Both => "BOTH", Leading => "LEADING", Trailing => "TRAILING", }) } } apache-datafusion-sqlparser-rs-0.62.0/src/ast/visitor.rs000066400000000000000000001165761517524037000232560ustar00rootroot00000000000000// 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. //! Recursive visitors for ast Nodes. See [`Visitor`] for more details. use crate::ast::{Expr, ObjectName, Query, Select, Statement, TableFactor, ValueWithSpan}; use core::ops::ControlFlow; /// A type that can be visited by a [`Visitor`]. See [`Visitor`] for /// recursively visiting parsed SQL statements. /// /// # Note /// /// This trait should be automatically derived for sqlparser AST nodes /// using the [Visit](sqlparser_derive::Visit) proc macro. /// /// ```text /// #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// ``` pub trait Visit { /// Visit this node with the provided [`Visitor`]. /// /// Implementations should call the appropriate visitor hooks to traverse /// child nodes and return a `ControlFlow` value to allow early exit. fn visit(&self, visitor: &mut V) -> ControlFlow; } /// A type that can be visited by a [`VisitorMut`]. See [`VisitorMut`] for /// recursively visiting parsed SQL statements. /// /// # Note /// /// This trait should be automatically derived for sqlparser AST nodes /// using the [VisitMut](sqlparser_derive::VisitMut) proc macro. /// /// ```text /// #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// ``` pub trait VisitMut { /// Mutably visit this node with the provided [`VisitorMut`]. /// /// Implementations should call the appropriate mutable visitor hooks to /// traverse and allow in-place mutation of child nodes. Returning a /// `ControlFlow` value permits early termination of the traversal. fn visit(&mut self, visitor: &mut V) -> ControlFlow; } impl Visit for Option { fn visit(&self, visitor: &mut V) -> ControlFlow { if let Some(s) = self { s.visit(visitor)?; } ControlFlow::Continue(()) } } impl Visit for Vec { fn visit(&self, visitor: &mut V) -> ControlFlow { for v in self { v.visit(visitor)?; } ControlFlow::Continue(()) } } impl Visit for Box { fn visit(&self, visitor: &mut V) -> ControlFlow { T::visit(self, visitor) } } impl VisitMut for Option { fn visit(&mut self, visitor: &mut V) -> ControlFlow { if let Some(s) = self { s.visit(visitor)?; } ControlFlow::Continue(()) } } impl VisitMut for Vec { fn visit(&mut self, visitor: &mut V) -> ControlFlow { for v in self { v.visit(visitor)?; } ControlFlow::Continue(()) } } impl VisitMut for Box { fn visit(&mut self, visitor: &mut V) -> ControlFlow { T::visit(self, visitor) } } macro_rules! visit_noop { ($($t:ty),+) => { $(impl Visit for $t { fn visit(&self, _visitor: &mut V) -> ControlFlow { ControlFlow::Continue(()) } })+ $(impl VisitMut for $t { fn visit(&mut self, _visitor: &mut V) -> ControlFlow { ControlFlow::Continue(()) } })+ }; } visit_noop!(u8, u16, u32, u64, i8, i16, i32, i64, char, bool, String); #[cfg(feature = "bigdecimal")] visit_noop!(bigdecimal::BigDecimal); /// A visitor that can be used to walk an AST tree. /// /// `pre_visit_` methods are invoked before visiting all children of the /// node and `post_visit_` methods are invoked after visiting all /// children of the node. /// /// # See also /// /// These methods provide a more concise way of visiting nodes of a certain type: /// * [visit_relations] /// * [visit_expressions] /// * [visit_statements] /// /// # Example /// ``` /// # use sqlparser::parser::Parser; /// # use sqlparser::dialect::GenericDialect; /// # use sqlparser::ast::{Visit, Visitor, ObjectName, Expr}; /// # use core::ops::ControlFlow; /// // A structure that records statements and relations /// #[derive(Default)] /// struct V { /// visited: Vec, /// } /// /// // Visit relations and exprs before children are visited (depth first walk) /// // Note you can also visit statements and visit exprs after children have been visited /// impl Visitor for V { /// type Break = (); /// /// fn pre_visit_relation(&mut self, relation: &ObjectName) -> ControlFlow { /// self.visited.push(format!("PRE: RELATION: {}", relation)); /// ControlFlow::Continue(()) /// } /// /// fn pre_visit_expr(&mut self, expr: &Expr) -> ControlFlow { /// self.visited.push(format!("PRE: EXPR: {}", expr)); /// ControlFlow::Continue(()) /// } /// } /// /// let sql = "SELECT a FROM foo where x IN (SELECT y FROM bar)"; /// let statements = Parser::parse_sql(&GenericDialect{}, sql) /// .unwrap(); /// /// // Drive the visitor through the AST /// let mut visitor = V::default(); /// statements.visit(&mut visitor); /// /// // The visitor has visited statements and expressions in pre-traversal order /// let expected : Vec<_> = [ /// "PRE: EXPR: a", /// "PRE: RELATION: foo", /// "PRE: EXPR: x IN (SELECT y FROM bar)", /// "PRE: EXPR: x", /// "PRE: EXPR: y", /// "PRE: RELATION: bar", /// ] /// .into_iter().map(|s| s.to_string()).collect(); /// /// assert_eq!(visitor.visited, expected); /// ``` pub trait Visitor { /// Type returned when the recursion returns early. /// /// Important note: The `Break` type should be kept as small as possible to prevent /// stack overflow during recursion. If you need to return an error, consider /// boxing it with `Box` to minimize stack usage. type Break; /// Invoked for any queries that appear in the AST before visiting children fn pre_visit_query(&mut self, _query: &Query) -> ControlFlow { ControlFlow::Continue(()) } /// Invoked for any queries that appear in the AST after visiting children fn post_visit_query(&mut self, _query: &Query) -> ControlFlow { ControlFlow::Continue(()) } /// Invoked for any [Select] that appear in the AST before visiting children fn pre_visit_select(&mut self, _select: &Select) -> ControlFlow { ControlFlow::Continue(()) } /// Invoked for any [Select] that appear in the AST after visiting children fn post_visit_select(&mut self, _select: &Select) -> ControlFlow { ControlFlow::Continue(()) } /// Invoked for any relations (e.g. tables) that appear in the AST before visiting children fn pre_visit_relation(&mut self, _relation: &ObjectName) -> ControlFlow { ControlFlow::Continue(()) } /// Invoked for any relations (e.g. tables) that appear in the AST after visiting children fn post_visit_relation(&mut self, _relation: &ObjectName) -> ControlFlow { ControlFlow::Continue(()) } /// Invoked for any table factors that appear in the AST before visiting children fn pre_visit_table_factor(&mut self, _table_factor: &TableFactor) -> ControlFlow { ControlFlow::Continue(()) } /// Invoked for any table factors that appear in the AST after visiting children fn post_visit_table_factor(&mut self, _table_factor: &TableFactor) -> ControlFlow { ControlFlow::Continue(()) } /// Invoked for any expressions that appear in the AST before visiting children fn pre_visit_expr(&mut self, _expr: &Expr) -> ControlFlow { ControlFlow::Continue(()) } /// Invoked for any expressions that appear in the AST fn post_visit_expr(&mut self, _expr: &Expr) -> ControlFlow { ControlFlow::Continue(()) } /// Invoked for any statements that appear in the AST before visiting children fn pre_visit_statement(&mut self, _statement: &Statement) -> ControlFlow { ControlFlow::Continue(()) } /// Invoked for any statements that appear in the AST after visiting children fn post_visit_statement(&mut self, _statement: &Statement) -> ControlFlow { ControlFlow::Continue(()) } /// Invoked for any Value that appear in the AST before visiting children fn pre_visit_value(&mut self, _value: &ValueWithSpan) -> ControlFlow { ControlFlow::Continue(()) } /// Invoked for any Value that appear in the AST after visiting children fn post_visit_value(&mut self, _value: &ValueWithSpan) -> ControlFlow { ControlFlow::Continue(()) } } /// A visitor that can be used to mutate an AST tree. /// /// `pre_visit_` methods are invoked before visiting all children of the /// node and `post_visit_` methods are invoked after visiting all /// children of the node. /// /// # See also /// /// These methods provide a more concise way of visiting nodes of a certain type: /// * [visit_relations_mut] /// * [visit_expressions_mut] /// * [visit_statements_mut] /// /// # Example /// ``` /// # use sqlparser::parser::Parser; /// # use sqlparser::dialect::GenericDialect; /// # use sqlparser::ast::{VisitMut, VisitorMut, ObjectName, Expr, Ident}; /// # use core::ops::ControlFlow; /// /// // A visitor that replaces "to_replace" with "replaced" in all expressions /// struct Replacer; /// /// // Visit each expression after its children have been visited /// impl VisitorMut for Replacer { /// type Break = (); /// /// fn post_visit_expr(&mut self, expr: &mut Expr) -> ControlFlow { /// if let Expr::Identifier(Ident{ value, ..}) = expr { /// *value = value.replace("to_replace", "replaced") /// } /// ControlFlow::Continue(()) /// } /// } /// /// let sql = "SELECT to_replace FROM foo where to_replace IN (SELECT to_replace FROM bar)"; /// let mut statements = Parser::parse_sql(&GenericDialect{}, sql).unwrap(); /// /// // Drive the visitor through the AST /// statements.visit(&mut Replacer); /// /// assert_eq!(statements[0].to_string(), "SELECT replaced FROM foo WHERE replaced IN (SELECT replaced FROM bar)"); /// ``` pub trait VisitorMut { /// Type returned when the recursion returns early. /// /// Important note: The `Break` type should be kept as small as possible to prevent /// stack overflow during recursion. If you need to return an error, consider /// boxing it with `Box` to minimize stack usage. type Break; /// Invoked for any queries that appear in the AST before visiting children fn pre_visit_query(&mut self, _query: &mut Query) -> ControlFlow { ControlFlow::Continue(()) } /// Invoked for any queries that appear in the AST after visiting children fn post_visit_query(&mut self, _query: &mut Query) -> ControlFlow { ControlFlow::Continue(()) } /// Invoked for any [Select] that appear in the AST before visiting children fn pre_visit_select(&mut self, _select: &mut Select) -> ControlFlow { ControlFlow::Continue(()) } /// Invoked for any [Select] that appear in the AST after visiting children fn post_visit_select(&mut self, _select: &mut Select) -> ControlFlow { ControlFlow::Continue(()) } /// Invoked for any relations (e.g. tables) that appear in the AST before visiting children fn pre_visit_relation(&mut self, _relation: &mut ObjectName) -> ControlFlow { ControlFlow::Continue(()) } /// Invoked for any relations (e.g. tables) that appear in the AST after visiting children fn post_visit_relation(&mut self, _relation: &mut ObjectName) -> ControlFlow { ControlFlow::Continue(()) } /// Invoked for any table factors that appear in the AST before visiting children fn pre_visit_table_factor( &mut self, _table_factor: &mut TableFactor, ) -> ControlFlow { ControlFlow::Continue(()) } /// Invoked for any table factors that appear in the AST after visiting children fn post_visit_table_factor( &mut self, _table_factor: &mut TableFactor, ) -> ControlFlow { ControlFlow::Continue(()) } /// Invoked for any expressions that appear in the AST before visiting children fn pre_visit_expr(&mut self, _expr: &mut Expr) -> ControlFlow { ControlFlow::Continue(()) } /// Invoked for any expressions that appear in the AST fn post_visit_expr(&mut self, _expr: &mut Expr) -> ControlFlow { ControlFlow::Continue(()) } /// Invoked for any statements that appear in the AST before visiting children fn pre_visit_statement(&mut self, _statement: &mut Statement) -> ControlFlow { ControlFlow::Continue(()) } /// Invoked for any statements that appear in the AST after visiting children fn post_visit_statement(&mut self, _statement: &mut Statement) -> ControlFlow { ControlFlow::Continue(()) } /// Invoked for any value that appear in the AST before visiting children fn pre_visit_value(&mut self, _value: &mut ValueWithSpan) -> ControlFlow { ControlFlow::Continue(()) } /// Invoked for any statements that appear in the AST after visiting children fn post_visit_value(&mut self, _value: &mut ValueWithSpan) -> ControlFlow { ControlFlow::Continue(()) } } struct RelationVisitor(F); impl ControlFlow> Visitor for RelationVisitor { type Break = E; fn pre_visit_relation(&mut self, relation: &ObjectName) -> ControlFlow { self.0(relation) } } impl ControlFlow> VisitorMut for RelationVisitor { type Break = E; fn post_visit_relation(&mut self, relation: &mut ObjectName) -> ControlFlow { self.0(relation) } } /// Invokes the provided closure on all relations (e.g. table names) present in `v` /// /// # Example /// ``` /// # use sqlparser::parser::Parser; /// # use sqlparser::dialect::GenericDialect; /// # use sqlparser::ast::{visit_relations}; /// # use core::ops::ControlFlow; /// let sql = "SELECT a FROM foo where x IN (SELECT y FROM bar)"; /// let statements = Parser::parse_sql(&GenericDialect{}, sql) /// .unwrap(); /// /// // visit statements, capturing relations (table names) /// let mut visited = vec![]; /// visit_relations(&statements, |relation| { /// visited.push(format!("RELATION: {}", relation)); /// ControlFlow::<()>::Continue(()) /// }); /// /// let expected : Vec<_> = [ /// "RELATION: foo", /// "RELATION: bar", /// ] /// .into_iter().map(|s| s.to_string()).collect(); /// /// assert_eq!(visited, expected); /// ``` pub fn visit_relations(v: &V, f: F) -> ControlFlow where V: Visit, F: FnMut(&ObjectName) -> ControlFlow, { let mut visitor = RelationVisitor(f); v.visit(&mut visitor)?; ControlFlow::Continue(()) } /// Invokes the provided closure with a mutable reference to all relations (e.g. table names) /// present in `v`. /// /// When the closure mutates its argument, the new mutated relation will not be visited again. /// /// # Example /// ``` /// # use sqlparser::parser::Parser; /// # use sqlparser::dialect::GenericDialect; /// # use sqlparser::ast::{ObjectName, ObjectNamePart, Ident, visit_relations_mut}; /// # use core::ops::ControlFlow; /// let sql = "SELECT a FROM foo"; /// let mut statements = Parser::parse_sql(&GenericDialect{}, sql) /// .unwrap(); /// /// // visit statements, renaming table foo to bar /// visit_relations_mut(&mut statements, |table| { /// table.0[0] = ObjectNamePart::Identifier(Ident::new("bar")); /// ControlFlow::<()>::Continue(()) /// }); /// /// assert_eq!(statements[0].to_string(), "SELECT a FROM bar"); /// ``` pub fn visit_relations_mut(v: &mut V, f: F) -> ControlFlow where V: VisitMut, F: FnMut(&mut ObjectName) -> ControlFlow, { let mut visitor = RelationVisitor(f); v.visit(&mut visitor)?; ControlFlow::Continue(()) } struct ExprVisitor(F); impl ControlFlow> Visitor for ExprVisitor { type Break = E; fn pre_visit_expr(&mut self, expr: &Expr) -> ControlFlow { self.0(expr) } } impl ControlFlow> VisitorMut for ExprVisitor { type Break = E; fn post_visit_expr(&mut self, expr: &mut Expr) -> ControlFlow { self.0(expr) } } /// Invokes the provided closure on all expressions (e.g. `1 + 2`) present in `v` /// /// # Example /// ``` /// # use sqlparser::parser::Parser; /// # use sqlparser::dialect::GenericDialect; /// # use sqlparser::ast::{visit_expressions}; /// # use core::ops::ControlFlow; /// let sql = "SELECT a FROM foo where x IN (SELECT y FROM bar)"; /// let statements = Parser::parse_sql(&GenericDialect{}, sql) /// .unwrap(); /// /// // visit all expressions /// let mut visited = vec![]; /// visit_expressions(&statements, |expr| { /// visited.push(format!("EXPR: {}", expr)); /// ControlFlow::<()>::Continue(()) /// }); /// /// let expected : Vec<_> = [ /// "EXPR: a", /// "EXPR: x IN (SELECT y FROM bar)", /// "EXPR: x", /// "EXPR: y", /// ] /// .into_iter().map(|s| s.to_string()).collect(); /// /// assert_eq!(visited, expected); /// ``` pub fn visit_expressions(v: &V, f: F) -> ControlFlow where V: Visit, F: FnMut(&Expr) -> ControlFlow, { let mut visitor = ExprVisitor(f); v.visit(&mut visitor)?; ControlFlow::Continue(()) } /// Invokes the provided closure iteratively with a mutable reference to all expressions /// present in `v`. /// /// This performs a depth-first search, so if the closure mutates the expression /// /// # Example /// /// ## Remove all select limits in sub-queries /// ``` /// # use sqlparser::parser::Parser; /// # use sqlparser::dialect::GenericDialect; /// # use sqlparser::ast::{Expr, visit_expressions_mut, visit_statements_mut}; /// # use core::ops::ControlFlow; /// let sql = "SELECT (SELECT y FROM z LIMIT 9) FROM t LIMIT 3"; /// let mut statements = Parser::parse_sql(&GenericDialect{}, sql).unwrap(); /// /// // Remove all select limits in sub-queries /// visit_expressions_mut(&mut statements, |expr| { /// if let Expr::Subquery(q) = expr { /// q.limit_clause = None; /// } /// ControlFlow::<()>::Continue(()) /// }); /// /// assert_eq!(statements[0].to_string(), "SELECT (SELECT y FROM z) FROM t LIMIT 3"); /// ``` /// /// ## Wrap column name in function call /// /// This demonstrates how to effectively replace an expression with another more complicated one /// that references the original. This example avoids unnecessary allocations by using the /// [`std::mem`] family of functions. /// /// ``` /// # use sqlparser::parser::Parser; /// # use sqlparser::dialect::GenericDialect; /// # use sqlparser::ast::*; /// # use core::ops::ControlFlow; /// let sql = "SELECT x, y FROM t"; /// let mut statements = Parser::parse_sql(&GenericDialect{}, sql).unwrap(); /// /// 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)); /// *expr = Expr::Function(Function { /// name: ObjectName::from(vec![Ident::new("f")]), /// uses_odbc_syntax: false, /// args: FunctionArguments::List(FunctionArgumentList { /// duplicate_treatment: None, /// args: vec![FunctionArg::Unnamed(FunctionArgExpr::Expr(old_expr))], /// clauses: vec![], /// }), /// null_treatment: None, /// filter: None, /// over: None, /// parameters: FunctionArguments::None, /// within_group: vec![], /// }); /// } /// ControlFlow::<()>::Continue(()) /// }); /// /// assert_eq!(statements[0].to_string(), "SELECT f(x), y FROM t"); /// ``` pub fn visit_expressions_mut(v: &mut V, f: F) -> ControlFlow where V: VisitMut, F: FnMut(&mut Expr) -> ControlFlow, { v.visit(&mut ExprVisitor(f))?; ControlFlow::Continue(()) } struct StatementVisitor(F); impl ControlFlow> Visitor for StatementVisitor { type Break = E; fn pre_visit_statement(&mut self, statement: &Statement) -> ControlFlow { self.0(statement) } } impl ControlFlow> VisitorMut for StatementVisitor { type Break = E; fn post_visit_statement(&mut self, statement: &mut Statement) -> ControlFlow { self.0(statement) } } /// Invokes the provided closure iteratively with a mutable reference to all statements /// present in `v` (e.g. `SELECT`, `CREATE TABLE`, etc). /// /// # Example /// ``` /// # use sqlparser::parser::Parser; /// # use sqlparser::dialect::GenericDialect; /// # use sqlparser::ast::{visit_statements}; /// # use core::ops::ControlFlow; /// let sql = "SELECT a FROM foo where x IN (SELECT y FROM bar); CREATE TABLE baz(q int)"; /// let statements = Parser::parse_sql(&GenericDialect{}, sql) /// .unwrap(); /// /// // visit all statements /// let mut visited = vec![]; /// visit_statements(&statements, |stmt| { /// visited.push(format!("STATEMENT: {}", stmt)); /// ControlFlow::<()>::Continue(()) /// }); /// /// let expected : Vec<_> = [ /// "STATEMENT: SELECT a FROM foo WHERE x IN (SELECT y FROM bar)", /// "STATEMENT: CREATE TABLE baz (q INT)" /// ] /// .into_iter().map(|s| s.to_string()).collect(); /// /// assert_eq!(visited, expected); /// ``` pub fn visit_statements(v: &V, f: F) -> ControlFlow where V: Visit, F: FnMut(&Statement) -> ControlFlow, { let mut visitor = StatementVisitor(f); v.visit(&mut visitor)?; ControlFlow::Continue(()) } /// Invokes the provided closure on all statements (e.g. `SELECT`, `CREATE TABLE`, etc) present in `v` /// /// # Example /// ``` /// # use sqlparser::parser::Parser; /// # use sqlparser::dialect::GenericDialect; /// # use sqlparser::ast::{Statement, visit_statements_mut}; /// # use core::ops::ControlFlow; /// let sql = "SELECT x FROM foo LIMIT 9+$limit; SELECT * FROM t LIMIT f()"; /// let mut statements = Parser::parse_sql(&GenericDialect{}, sql).unwrap(); /// /// // 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; /// } /// ControlFlow::<()>::Continue(()) /// }); /// /// assert_eq!(statements[0].to_string(), "SELECT x FROM foo"); /// assert_eq!(statements[1].to_string(), "SELECT * FROM t"); /// ``` pub fn visit_statements_mut(v: &mut V, f: F) -> ControlFlow where V: VisitMut, F: FnMut(&mut Statement) -> ControlFlow, { v.visit(&mut StatementVisitor(f))?; ControlFlow::Continue(()) } #[cfg(test)] mod tests { use super::*; use crate::ast::Statement; use crate::dialect::GenericDialect; use crate::parser::Parser; use crate::tokenizer::Tokenizer; #[derive(Default)] struct TestVisitor { visited: Vec, } impl Visitor for TestVisitor { type Break = (); /// Invoked for any queries that appear in the AST before visiting children fn pre_visit_query(&mut self, query: &Query) -> ControlFlow { self.visited.push(format!("PRE: QUERY: {query}")); ControlFlow::Continue(()) } /// Invoked for any queries that appear in the AST after visiting children fn post_visit_query(&mut self, query: &Query) -> ControlFlow { self.visited.push(format!("POST: QUERY: {query}")); ControlFlow::Continue(()) } fn pre_visit_select(&mut self, select: &Select) -> ControlFlow { self.visited.push(format!("PRE: SELECT: {select}")); ControlFlow::Continue(()) } fn post_visit_select(&mut self, select: &Select) -> ControlFlow { self.visited.push(format!("POST: SELECT: {select}")); ControlFlow::Continue(()) } fn pre_visit_relation(&mut self, relation: &ObjectName) -> ControlFlow { self.visited.push(format!("PRE: RELATION: {relation}")); ControlFlow::Continue(()) } fn post_visit_relation(&mut self, relation: &ObjectName) -> ControlFlow { self.visited.push(format!("POST: RELATION: {relation}")); ControlFlow::Continue(()) } fn pre_visit_table_factor( &mut self, table_factor: &TableFactor, ) -> ControlFlow { self.visited .push(format!("PRE: TABLE FACTOR: {table_factor}")); ControlFlow::Continue(()) } fn post_visit_table_factor( &mut self, table_factor: &TableFactor, ) -> ControlFlow { self.visited .push(format!("POST: TABLE FACTOR: {table_factor}")); ControlFlow::Continue(()) } fn pre_visit_expr(&mut self, expr: &Expr) -> ControlFlow { self.visited.push(format!("PRE: EXPR: {expr}")); ControlFlow::Continue(()) } fn post_visit_expr(&mut self, expr: &Expr) -> ControlFlow { self.visited.push(format!("POST: EXPR: {expr}")); ControlFlow::Continue(()) } fn pre_visit_statement(&mut self, statement: &Statement) -> ControlFlow { self.visited.push(format!("PRE: STATEMENT: {statement}")); ControlFlow::Continue(()) } fn post_visit_statement(&mut self, statement: &Statement) -> ControlFlow { self.visited.push(format!("POST: STATEMENT: {statement}")); ControlFlow::Continue(()) } } fn do_visit>(sql: &str, visitor: &mut V) -> Statement { let dialect = GenericDialect {}; let tokens = Tokenizer::new(&dialect, sql).tokenize().unwrap(); let s = Parser::new(&dialect) .with_tokens(tokens) .parse_statement() .unwrap(); let flow = s.visit(visitor); assert_eq!(flow, ControlFlow::Continue(())); s } #[test] fn test_sql() { let tests = vec![ ( "SELECT * from table_name as my_table", vec![ "PRE: STATEMENT: SELECT * FROM table_name AS my_table", "PRE: QUERY: SELECT * FROM table_name AS my_table", "PRE: SELECT: SELECT * FROM table_name AS my_table", "PRE: TABLE FACTOR: table_name AS my_table", "PRE: RELATION: table_name", "POST: RELATION: table_name", "POST: TABLE FACTOR: table_name AS my_table", "POST: SELECT: SELECT * FROM table_name AS my_table", "POST: QUERY: SELECT * FROM table_name AS my_table", "POST: STATEMENT: SELECT * FROM table_name AS my_table", ], ), ( "SELECT * from t1 join t2 on t1.id = t2.t1_id", vec![ "PRE: STATEMENT: SELECT * FROM t1 JOIN t2 ON t1.id = t2.t1_id", "PRE: QUERY: SELECT * FROM t1 JOIN t2 ON t1.id = t2.t1_id", "PRE: SELECT: SELECT * FROM t1 JOIN t2 ON t1.id = t2.t1_id", "PRE: TABLE FACTOR: t1", "PRE: RELATION: t1", "POST: RELATION: t1", "POST: TABLE FACTOR: t1", "PRE: TABLE FACTOR: t2", "PRE: RELATION: t2", "POST: RELATION: t2", "POST: TABLE FACTOR: t2", "PRE: EXPR: t1.id = t2.t1_id", "PRE: EXPR: t1.id", "POST: EXPR: t1.id", "PRE: EXPR: t2.t1_id", "POST: EXPR: t2.t1_id", "POST: EXPR: t1.id = t2.t1_id", "POST: SELECT: SELECT * FROM t1 JOIN t2 ON t1.id = t2.t1_id", "POST: QUERY: SELECT * FROM t1 JOIN t2 ON t1.id = t2.t1_id", "POST: STATEMENT: SELECT * FROM t1 JOIN t2 ON t1.id = t2.t1_id", ], ), ( "SELECT * from t1 where EXISTS(SELECT column from t2)", vec![ "PRE: STATEMENT: SELECT * FROM t1 WHERE EXISTS (SELECT column FROM t2)", "PRE: QUERY: SELECT * FROM t1 WHERE EXISTS (SELECT column FROM t2)", "PRE: SELECT: SELECT * FROM t1 WHERE EXISTS (SELECT column FROM t2)", "PRE: TABLE FACTOR: t1", "PRE: RELATION: t1", "POST: RELATION: t1", "POST: TABLE FACTOR: t1", "PRE: EXPR: EXISTS (SELECT column FROM t2)", "PRE: QUERY: SELECT column FROM t2", "PRE: SELECT: SELECT column FROM t2", "PRE: EXPR: column", "POST: EXPR: column", "PRE: TABLE FACTOR: t2", "PRE: RELATION: t2", "POST: RELATION: t2", "POST: TABLE FACTOR: t2", "POST: SELECT: SELECT column FROM t2", "POST: QUERY: SELECT column FROM t2", "POST: EXPR: EXISTS (SELECT column FROM t2)", "POST: SELECT: SELECT * FROM t1 WHERE EXISTS (SELECT column FROM t2)", "POST: QUERY: SELECT * FROM t1 WHERE EXISTS (SELECT column FROM t2)", "POST: STATEMENT: SELECT * FROM t1 WHERE EXISTS (SELECT column FROM t2)", ], ), ( "SELECT * from t1 where EXISTS(SELECT column from t2)", vec![ "PRE: STATEMENT: SELECT * FROM t1 WHERE EXISTS (SELECT column FROM t2)", "PRE: QUERY: SELECT * FROM t1 WHERE EXISTS (SELECT column FROM t2)", "PRE: SELECT: SELECT * FROM t1 WHERE EXISTS (SELECT column FROM t2)", "PRE: TABLE FACTOR: t1", "PRE: RELATION: t1", "POST: RELATION: t1", "POST: TABLE FACTOR: t1", "PRE: EXPR: EXISTS (SELECT column FROM t2)", "PRE: QUERY: SELECT column FROM t2", "PRE: SELECT: SELECT column FROM t2", "PRE: EXPR: column", "POST: EXPR: column", "PRE: TABLE FACTOR: t2", "PRE: RELATION: t2", "POST: RELATION: t2", "POST: TABLE FACTOR: t2", "POST: SELECT: SELECT column FROM t2", "POST: QUERY: SELECT column FROM t2", "POST: EXPR: EXISTS (SELECT column FROM t2)", "POST: SELECT: SELECT * FROM t1 WHERE EXISTS (SELECT column FROM t2)", "POST: QUERY: SELECT * FROM t1 WHERE EXISTS (SELECT column FROM t2)", "POST: STATEMENT: SELECT * FROM t1 WHERE EXISTS (SELECT column FROM t2)", ], ), ( "SELECT * from t1 where EXISTS(SELECT column from t2) UNION SELECT * from t3", vec![ "PRE: STATEMENT: SELECT * FROM t1 WHERE EXISTS (SELECT column FROM t2) UNION SELECT * FROM t3", "PRE: QUERY: SELECT * FROM t1 WHERE EXISTS (SELECT column FROM t2) UNION SELECT * FROM t3", "PRE: SELECT: SELECT * FROM t1 WHERE EXISTS (SELECT column FROM t2)", "PRE: TABLE FACTOR: t1", "PRE: RELATION: t1", "POST: RELATION: t1", "POST: TABLE FACTOR: t1", "PRE: EXPR: EXISTS (SELECT column FROM t2)", "PRE: QUERY: SELECT column FROM t2", "PRE: SELECT: SELECT column FROM t2", "PRE: EXPR: column", "POST: EXPR: column", "PRE: TABLE FACTOR: t2", "PRE: RELATION: t2", "POST: RELATION: t2", "POST: TABLE FACTOR: t2", "POST: SELECT: SELECT column FROM t2", "POST: QUERY: SELECT column FROM t2", "POST: EXPR: EXISTS (SELECT column FROM t2)", "POST: SELECT: SELECT * FROM t1 WHERE EXISTS (SELECT column FROM t2)", "PRE: SELECT: SELECT * FROM t3", "PRE: TABLE FACTOR: t3", "PRE: RELATION: t3", "POST: RELATION: t3", "POST: TABLE FACTOR: t3", "POST: SELECT: SELECT * FROM t3", "POST: QUERY: SELECT * FROM t1 WHERE EXISTS (SELECT column FROM t2) UNION SELECT * FROM t3", "POST: STATEMENT: SELECT * FROM t1 WHERE EXISTS (SELECT column FROM t2) UNION SELECT * FROM t3", ], ), ( concat!( "SELECT * FROM monthly_sales ", "PIVOT(SUM(a.amount) FOR a.MONTH IN ('JAN', 'FEB', 'MAR', 'APR')) AS p (c, d) ", "ORDER BY EMPID" ), vec![ "PRE: STATEMENT: SELECT * FROM monthly_sales PIVOT(SUM(a.amount) FOR a.MONTH IN ('JAN', 'FEB', 'MAR', 'APR')) AS p (c, d) ORDER BY EMPID", "PRE: QUERY: SELECT * FROM monthly_sales PIVOT(SUM(a.amount) FOR a.MONTH IN ('JAN', 'FEB', 'MAR', 'APR')) AS p (c, d) ORDER BY EMPID", "PRE: SELECT: SELECT * FROM monthly_sales PIVOT(SUM(a.amount) FOR a.MONTH IN ('JAN', 'FEB', 'MAR', 'APR')) AS p (c, d)", "PRE: TABLE FACTOR: monthly_sales PIVOT(SUM(a.amount) FOR a.MONTH IN ('JAN', 'FEB', 'MAR', 'APR')) AS p (c, d)", "PRE: TABLE FACTOR: monthly_sales", "PRE: RELATION: monthly_sales", "POST: RELATION: monthly_sales", "POST: TABLE FACTOR: monthly_sales", "PRE: EXPR: SUM(a.amount)", "PRE: EXPR: a.amount", "POST: EXPR: a.amount", "POST: EXPR: SUM(a.amount)", "PRE: EXPR: a.MONTH", "POST: EXPR: a.MONTH", "PRE: EXPR: 'JAN'", "POST: EXPR: 'JAN'", "PRE: EXPR: 'FEB'", "POST: EXPR: 'FEB'", "PRE: EXPR: 'MAR'", "POST: EXPR: 'MAR'", "PRE: EXPR: 'APR'", "POST: EXPR: 'APR'", "POST: TABLE FACTOR: monthly_sales PIVOT(SUM(a.amount) FOR a.MONTH IN ('JAN', 'FEB', 'MAR', 'APR')) AS p (c, d)", "POST: SELECT: SELECT * FROM monthly_sales PIVOT(SUM(a.amount) FOR a.MONTH IN ('JAN', 'FEB', 'MAR', 'APR')) AS p (c, d)", "PRE: EXPR: EMPID", "POST: EXPR: EMPID", "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(); 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::>() .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, ValueWithSpan, 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 ValueWithSpan) -> ControlFlow { self.index += 1; value.value = Value::SingleQuotedString(format!("REDACTED_{}", self.index)); ControlFlow::Continue(()) } fn post_visit_value(&mut self, _value: &mut ValueWithSpan) -> ControlFlow { ControlFlow::Continue(()) } } fn do_visit_mut>(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) } } } apache-datafusion-sqlparser-rs-0.62.0/src/dialect/000077500000000000000000000000001517524037000220075ustar00rootroot00000000000000apache-datafusion-sqlparser-rs-0.62.0/src/dialect/ansi.rs000066400000000000000000000031031517524037000233040ustar00rootroot00000000000000// 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 crate::dialect::Dialect; /// A [`Dialect`] for [ANSI SQL](https://en.wikipedia.org/wiki/SQL:2011). #[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct AnsiDialect {} impl Dialect for AnsiDialect { fn is_identifier_start(&self, ch: char) -> bool { ch.is_ascii_lowercase() || ch.is_ascii_uppercase() } fn is_identifier_part(&self, ch: char) -> bool { ch.is_ascii_lowercase() || ch.is_ascii_uppercase() || ch.is_ascii_digit() || ch == '_' } fn require_interval_qualifier(&self) -> bool { true } /// The SQL standard explicitly states that block comments nest. fn supports_nested_comments(&self) -> bool { true } } apache-datafusion-sqlparser-rs-0.62.0/src/dialect/bigquery.rs000066400000000000000000000133411517524037000242060ustar00rootroot00000000000000// 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 crate::ast::Statement; use crate::dialect::Dialect; use crate::keywords::Keyword; use crate::parser::{Parser, ParserError}; use crate::tokenizer::Token; /// These keywords are disallowed as column identifiers. Such that /// `SELECT 5 AS 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, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct BigQueryDialect; impl Dialect for BigQueryDialect { fn parse_statement(&self, parser: &mut Parser) -> Option> { if parser.parse_keyword(Keyword::BEGIN) { if parser.peek_keyword(Keyword::TRANSACTION) || parser.peek_token_ref().token == Token::SemiColon || parser.peek_token_ref().token == Token::EOF { parser.prev_token(); return None; } return Some(parser.parse_begin_exception_end()); } None } /// See fn is_delimited_identifier_start(&self, ch: char) -> bool { ch == '`' } fn supports_projection_trailing_commas(&self) -> bool { true } /// See 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 { ch.is_ascii_lowercase() || ch.is_ascii_uppercase() || ch.is_ascii_digit() || ch == '_' } /// See [doc](https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#quoted_literals) fn supports_triple_quoted_string(&self) -> bool { true } /// See [doc](https://cloud.google.com/bigquery/docs/reference/standard-sql/navigation_functions#first_value) fn supports_window_function_null_treatment_arg(&self) -> bool { true } // See https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#escape_sequences fn supports_string_literal_backslash_escape(&self) -> bool { true } /// See [doc](https://cloud.google.com/bigquery/docs/reference/standard-sql/window-function-calls#ref_named_window) fn supports_window_clause_named_window_reference(&self) -> bool { true } /// See [doc](https://cloud.google.com/bigquery/docs/reference/standard-sql/procedural-language#set) fn supports_parenthesized_set_variables(&self) -> bool { true } // See https://cloud.google.com/bigquery/docs/reference/standard-sql/query-syntax#select_except fn supports_select_wildcard_except(&self) -> bool { true } 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 fn supports_select_expr_star(&self) -> bool { true } /// See fn supports_execute_immediate(&self) -> bool { true } // See fn supports_table_versioning(&self) -> bool { true } // See 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 } fn supports_create_table_multi_schema_info_sources(&self) -> bool { true } /// See fn supports_select_wildcard_replace(&self) -> bool { true } fn supports_comma_separated_trim(&self) -> bool { true } } apache-datafusion-sqlparser-rs-0.62.0/src/dialect/clickhouse.rs000066400000000000000000000114221517524037000245060ustar00rootroot00000000000000// 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 crate::dialect::Dialect; /// A [`Dialect`] for [ClickHouse](https://clickhouse.com/). #[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct ClickHouseDialect {} impl Dialect for ClickHouseDialect { fn is_identifier_start(&self, ch: char) -> bool { // See https://clickhouse.com/docs/en/sql-reference/syntax/#syntax-identifiers ch.is_ascii_lowercase() || ch.is_ascii_uppercase() || ch == '_' } fn is_identifier_part(&self, ch: char) -> bool { self.is_identifier_start(ch) || ch.is_ascii_digit() } fn supports_string_literal_backslash_escape(&self) -> bool { true } fn supports_select_wildcard_except(&self) -> bool { true } fn describe_requires_table_keyword(&self) -> bool { true } fn require_interval_qualifier(&self) -> bool { true } 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 } fn supports_partition_by_after_order_by(&self) -> bool { true } fn supports_array_join_syntax(&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 fn supports_lambda_functions(&self) -> bool { true } fn supports_from_first_select(&self) -> bool { true } /// See fn supports_order_by_all(&self) -> bool { true } // See fn supports_group_by_expr(&self) -> bool { true } /// See fn supports_group_by_with_modifier(&self) -> bool { true } /// Supported since 2020. /// See fn supports_nested_comments(&self) -> bool { true } /// See fn supports_optimize_table(&self) -> bool { true } /// See fn supports_prewhere(&self) -> bool { true } /// See fn supports_with_fill(&self) -> bool { true } /// See fn supports_limit_by(&self) -> bool { true } /// See fn supports_interpolate(&self) -> bool { true } /// See fn supports_settings(&self) -> bool { true } /// See fn supports_select_format(&self) -> bool { true } /// See fn supports_select_wildcard_replace(&self) -> bool { true } fn supports_comma_separated_trim(&self) -> bool { true } } apache-datafusion-sqlparser-rs-0.62.0/src/dialect/databricks.rs000066400000000000000000000070571517524037000244750ustar00rootroot00000000000000// 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 crate::dialect::Dialect; /// A [`Dialect`] for [Databricks SQL](https://www.databricks.com/) /// /// See . #[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct DatabricksDialect; impl Dialect for DatabricksDialect { // see https://docs.databricks.com/en/sql/language-manual/sql-ref-identifiers.html fn is_delimited_identifier_start(&self, ch: char) -> bool { matches!(ch, '`') } fn is_identifier_start(&self, ch: char) -> bool { matches!(ch, 'a'..='z' | 'A'..='Z' | '_') } fn is_identifier_part(&self, ch: char) -> bool { matches!(ch, 'a'..='z' | 'A'..='Z' | '0'..='9' | '_') } fn supports_numeric_prefix(&self) -> bool { true } fn supports_filter_during_aggregation(&self) -> bool { true } // https://docs.databricks.com/en/sql/language-manual/sql-ref-syntax-qry-select-groupby.html fn supports_group_by_expr(&self) -> bool { true } /// fn supports_table_versioning(&self) -> bool { true } fn supports_lambda_functions(&self) -> bool { true } // https://docs.databricks.com/en/sql/language-manual/sql-ref-syntax-qry-select.html#syntax fn supports_select_wildcard_except(&self) -> bool { true } 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 } /// See fn supports_nested_comments(&self) -> bool { true } /// See fn supports_group_by_with_modifier(&self) -> bool { true } /// See fn supports_values_as_table_factor(&self) -> bool { true } /// See fn supports_optimize_table(&self) -> bool { true } /// See fn supports_bang_not_operator(&self) -> bool { true } /// See fn supports_cte_without_as(&self) -> bool { true } fn supports_select_item_multi_column_alias(&self) -> bool { true } } apache-datafusion-sqlparser-rs-0.62.0/src/dialect/duckdb.rs000066400000000000000000000101301517524037000236040ustar00rootroot00000000000000// 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 crate::dialect::Dialect; /// A [`Dialect`] for [DuckDB](https://duckdb.org/) #[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct DuckDbDialect; // In most cases the redshift dialect is identical to [`PostgresSqlDialect`]. impl Dialect for DuckDbDialect { fn supports_trailing_commas(&self) -> bool { true } fn is_identifier_start(&self, ch: char) -> bool { ch.is_alphabetic() || ch == '_' } fn is_identifier_part(&self, ch: char) -> bool { ch.is_alphabetic() || ch.is_ascii_digit() || ch == '$' || ch == '_' } fn supports_filter_during_aggregation(&self) -> bool { true } fn supports_group_by_expr(&self) -> bool { true } fn supports_bitwise_shift_operators(&self) -> bool { true } fn supports_named_fn_args_with_eq_operator(&self) -> bool { 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 fn supports_dictionary_syntax(&self) -> bool { true } // DuckDB uses this syntax for `MAP`s. // // https://duckdb.org/docs/sql/data_types/map.html#creating-maps fn support_map_literal_syntax(&self) -> bool { true } /// See fn supports_lambda_functions(&self) -> bool { true } /// Returns true if this dialect allows the `EXTRACT` function to use single quotes in the part being extracted. fn allow_extract_single_quotes(&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 fn supports_load_extension(&self) -> bool { true } // See DuckDB fn supports_array_typedef_with_brackets(&self) -> bool { true } fn supports_from_first_select(&self) -> bool { true } /// See DuckDB fn supports_order_by_all(&self) -> bool { true } fn supports_select_wildcard_exclude(&self) -> bool { true } /// DuckDB supports `NOTNULL` as an alias for `IS NOT NULL`, /// see DuckDB Comparisons fn supports_notnull_operator(&self) -> bool { true } /// See fn supports_install(&self) -> bool { true } /// See fn supports_detach(&self) -> bool { true } /// See fn supports_select_wildcard_replace(&self) -> bool { true } fn supports_comma_separated_trim(&self) -> bool { true } } apache-datafusion-sqlparser-rs-0.62.0/src/dialect/generic.rs000066400000000000000000000147341517524037000240020ustar00rootroot00000000000000// 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 crate::dialect::Dialect; /// A permissive, general purpose [`Dialect`], which parses a wide variety of SQL /// statements, from many different dialects. #[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct GenericDialect; impl Dialect for GenericDialect { fn is_delimited_identifier_start(&self, ch: char) -> bool { ch == '"' || ch == '`' } fn is_identifier_start(&self, ch: char) -> bool { ch.is_alphabetic() || ch == '_' || ch == '#' || ch == '@' } fn is_identifier_part(&self, ch: char) -> bool { ch.is_alphabetic() || ch.is_ascii_digit() || ch == '@' || ch == '$' || ch == '#' || ch == '_' } fn supports_unicode_string_literal(&self) -> bool { true } fn supports_partition_by_after_order_by(&self) -> bool { true } fn supports_array_join_syntax(&self) -> bool { true } fn supports_group_by_expr(&self) -> bool { 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 } fn supports_match_recognize(&self) -> bool { true } fn supports_pipe_operator(&self) -> bool { true } fn supports_start_transaction_modifier(&self) -> bool { true } fn supports_window_function_null_treatment_arg(&self) -> bool { true } fn supports_dictionary_syntax(&self) -> bool { true } fn supports_window_clause_named_window_reference(&self) -> bool { true } fn supports_parenthesized_set_variables(&self) -> bool { true } fn supports_select_wildcard_except(&self) -> bool { true } fn support_map_literal_syntax(&self) -> bool { true } fn allow_extract_custom(&self) -> bool { true } fn allow_extract_single_quotes(&self) -> bool { true } fn supports_extract_comma_syntax(&self) -> bool { true } fn supports_create_view_comment_syntax(&self) -> bool { true } fn supports_parens_around_table_factor(&self) -> bool { true } fn supports_values_as_table_factor(&self) -> bool { true } fn supports_create_index_with_clause(&self) -> bool { true } fn supports_explain_with_utility_options(&self) -> bool { true } fn supports_limit_comma(&self) -> bool { true } fn supports_update_order_by(&self) -> bool { 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 } fn supports_try_convert(&self) -> bool { true } fn supports_bitwise_shift_operators(&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_multiline_comment_hints(&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 } fn supports_select_wildcard_exclude(&self) -> bool { true } fn supports_data_type_signed_suffix(&self) -> bool { true } fn supports_interval_options(&self) -> bool { true } fn supports_quote_delimited_string(&self) -> bool { true } fn supports_select_wildcard_replace(&self) -> bool { true } fn supports_select_wildcard_ilike(&self) -> bool { true } fn supports_select_wildcard_rename(&self) -> bool { true } fn supports_optimize_table(&self) -> bool { true } fn supports_install(&self) -> bool { true } fn supports_detach(&self) -> bool { true } fn supports_prewhere(&self) -> bool { true } fn supports_with_fill(&self) -> bool { true } fn supports_limit_by(&self) -> bool { true } fn supports_interpolate(&self) -> bool { true } fn supports_settings(&self) -> bool { true } fn supports_select_format(&self) -> bool { true } fn supports_comment_optimizer_hint(&self) -> bool { true } fn supports_constraint_keyword_without_name(&self) -> bool { true } fn supports_key_column_option(&self) -> bool { true } fn supports_comma_separated_trim(&self) -> bool { true } fn supports_cte_without_as(&self) -> bool { true } fn supports_select_item_multi_column_alias(&self) -> bool { true } fn supports_xml_expressions(&self) -> bool { true } } apache-datafusion-sqlparser-rs-0.62.0/src/dialect/hive.rs000066400000000000000000000056041517524037000233150ustar00rootroot00000000000000// 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 crate::dialect::Dialect; /// A [`Dialect`] for [Hive](https://hive.apache.org/). #[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct HiveDialect {} impl Dialect for HiveDialect { fn is_delimited_identifier_start(&self, ch: char) -> bool { (ch == '"') || (ch == '`') } fn is_identifier_start(&self, ch: char) -> bool { ch.is_ascii_lowercase() || ch.is_ascii_uppercase() || ch.is_ascii_digit() || ch == '$' } fn is_identifier_part(&self, ch: char) -> bool { ch.is_ascii_lowercase() || ch.is_ascii_uppercase() || ch.is_ascii_digit() || ch == '_' || ch == '$' || ch == '{' || ch == '}' } fn supports_filter_during_aggregation(&self) -> bool { true } fn supports_numeric_prefix(&self) -> bool { true } fn require_interval_qualifier(&self) -> bool { true } /// See fn supports_bang_not_operator(&self) -> bool { true } /// See fn supports_load_data(&self) -> bool { true } /// See fn supports_table_sample_before_alias(&self) -> bool { true } /// See fn supports_group_by_with_modifier(&self) -> bool { true } // TODO: The parsing of the FROM keyword seems wrong, as it happens within the CTE. // See https://github.com/apache/datafusion-sqlparser-rs/issues/2236 for more details. /// See fn supports_from_first_insert(&self) -> bool { true } } apache-datafusion-sqlparser-rs-0.62.0/src/dialect/mod.rs000066400000000000000000002172341517524037000231450ustar00rootroot00000000000000// 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. mod ansi; mod bigquery; mod clickhouse; mod databricks; mod duckdb; mod generic; mod hive; mod mssql; mod mysql; mod oracle; mod postgresql; mod redshift; mod snowflake; mod spark; mod sqlite; mod teradata; use core::any::{Any, TypeId}; use core::fmt::Debug; use core::iter::Peekable; use core::str::Chars; use log::debug; pub use self::ansi::AnsiDialect; pub use self::bigquery::BigQueryDialect; pub use self::clickhouse::ClickHouseDialect; pub use self::databricks::DatabricksDialect; pub use self::duckdb::DuckDbDialect; pub use self::generic::GenericDialect; pub use self::hive::HiveDialect; pub use self::mssql::MsSqlDialect; pub use self::mysql::MySqlDialect; pub use self::oracle::OracleDialect; pub use self::postgresql::PostgreSqlDialect; pub use self::redshift::RedshiftSqlDialect; pub use self::snowflake::parse_snowflake_stage_name; pub use self::snowflake::SnowflakeDialect; pub use self::spark::SparkSqlDialect; pub use self::sqlite::SQLiteDialect; pub use self::teradata::TeradataDialect; /// Macro for streamlining the creation of derived `Dialect` objects. /// The generated struct includes `new()` and `default()` constructors. /// Requires the `derive-dialect` feature. /// /// # Syntax /// /// ```text /// derive_dialect!(NewDialect, BaseDialect); /// derive_dialect!(NewDialect, BaseDialect, overrides = { method = value, ... }); /// derive_dialect!(NewDialect, BaseDialect, preserve_type_id = true); /// derive_dialect!(NewDialect, BaseDialect, preserve_type_id = true, overrides = { ... }); /// ``` /// /// # Example /// /// ``` /// use sqlparser::derive_dialect; /// use sqlparser::dialect::{Dialect, GenericDialect}; /// /// // Override boolean methods (supports_*, allow_*, etc.) /// derive_dialect!(CustomDialect, GenericDialect, overrides = { /// supports_order_by_all = true, /// supports_nested_comments = true, /// }); /// /// let dialect = CustomDialect::new(); /// assert!(dialect.supports_order_by_all()); /// assert!(dialect.supports_nested_comments()); /// ``` /// /// # Overriding `identifier_quote_style` /// /// Use a char literal or `None`: /// ``` /// use sqlparser::derive_dialect; /// use sqlparser::dialect::{Dialect, PostgreSqlDialect}; /// /// derive_dialect!(BacktickPostgreSqlDialect, PostgreSqlDialect, /// preserve_type_id = true, /// overrides = { identifier_quote_style = '`' } /// ); /// let d: &dyn Dialect = &BacktickPostgreSqlDialect::new(); /// assert_eq!(d.identifier_quote_style("foo"), Some('`')); /// /// derive_dialect!(QuotelessPostgreSqlDialect, PostgreSqlDialect, /// preserve_type_id = true, /// overrides = { identifier_quote_style = None } /// ); /// let d: &dyn Dialect = &QuotelessPostgreSqlDialect::new(); /// assert_eq!(d.identifier_quote_style("foo"), None); /// ``` /// /// # Type Identity /// /// By default, derived dialects have their own `TypeId`. Set `preserve_type_id = true` to /// retain the base dialect's identity with respect to the parser's `dialect.is::()` checks: /// ``` /// use sqlparser::derive_dialect; /// use sqlparser::dialect::{Dialect, GenericDialect}; /// /// derive_dialect!(EnhancedGenericDialect, GenericDialect, /// preserve_type_id = true, /// overrides = { /// supports_order_by_all = true, /// supports_nested_comments = true, /// } /// ); /// let d: &dyn Dialect = &EnhancedGenericDialect::new(); /// assert!(d.is::()); // still recognized as a GenericDialect /// assert!(d.supports_nested_comments()); /// assert!(d.supports_order_by_all()); /// ``` #[cfg(feature = "derive-dialect")] pub use sqlparser_derive::derive_dialect; use crate::ast::{ColumnOption, Expr, GranteesType, Ident, ObjectNamePart, Statement}; pub use crate::keywords; use crate::keywords::Keyword; use crate::parser::{Parser, ParserError}; use crate::tokenizer::Token; #[cfg(not(feature = "std"))] use alloc::boxed::Box; /// Convenience check if a [`Parser`] uses a certain dialect. /// /// Note: when possible, please use the new style, adding a method to /// the [`Dialect`] trait rather than using this macro. /// /// The benefits of adding a method on `Dialect` over this macro are: /// 1. user defined [`Dialect`]s can customize the parsing behavior /// 2. The differences between dialects can be clearly documented in the trait /// /// `dialect_of!(parser is SQLiteDialect | GenericDialect)` evaluates /// to `true` if `parser.dialect` is one of the [`Dialect`]s specified. macro_rules! dialect_of { ( $parsed_dialect: ident is $($dialect_type: ty)|+ ) => { ($($parsed_dialect.dialect.is::<$dialect_type>())||+) }; } // 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 /// /// SQL implementations deviate from one another, either due to /// custom extensions or various historical reasons. This trait /// encapsulates the parsing differences between dialects. /// /// [`GenericDialect`] is the most permissive dialect, and parses the union of /// all the other dialects, when there is no ambiguity. However, it does not /// currently allow `CREATE TABLE` statements without types specified for all /// columns; use [`SQLiteDialect`] if you require that. /// /// # Examples /// Most users create a [`Dialect`] directly, as shown on the [module /// level documentation]: /// /// ``` /// # use sqlparser::dialect::AnsiDialect; /// let dialect = AnsiDialect {}; /// ``` /// /// It is also possible to dynamically create a [`Dialect`] from its /// name. For example: /// /// ``` /// # use sqlparser::dialect::{AnsiDialect, dialect_from_str}; /// let dialect = dialect_from_str("ansi").unwrap(); /// /// // Parsed dialect is an instance of `AnsiDialect`: /// assert!(dialect.is::()); /// ``` /// /// [module level documentation]: crate pub trait Dialect: Debug + Any { /// Determine the [`TypeId`] of this dialect. /// /// By default, return the same [`TypeId`] as [`Any::type_id`]. Can be overridden by /// dialects that behave like other dialects (for example, when wrapping a dialect). fn dialect(&self) -> TypeId { self.type_id() } /// Determine if a character starts a quoted identifier. The default /// implementation, accepting "double quoted" ids is both ANSI-compliant /// and appropriate for most dialects (with the notable exception of /// MySQL, MS SQL, and sqlite). You can accept one of characters listed /// in `Word::matching_end_quote` here fn is_delimited_identifier_start(&self, ch: char) -> bool { 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>, ) -> Option<(char, Option)> { None } /// Return the character used to quote identifiers. fn identifier_quote_style(&self, _identifier: &str) -> Option { None } /// Determine if a character is a valid start character for an unquoted identifier fn is_identifier_start(&self, ch: char) -> bool; /// Determine if a character is a valid unquoted identifier character fn is_identifier_part(&self, ch: char) -> bool; /// Most dialects do not have custom operators. Override this method to provide custom operators. fn is_custom_operator_part(&self, _ch: char) -> bool { false } /// Determine if the dialect supports escaping characters via '\' in string literals. /// /// Some dialects like BigQuery and Snowflake support this while others like /// Postgres do not. Such that the following is accepted by the former but /// rejected by the latter. /// ```sql /// SELECT 'ab\'cd'; /// ``` /// /// Conversely, such dialects reject the following statement which /// otherwise would be valid in the other dialects. /// ```sql /// SELECT '\'; /// ``` fn supports_string_literal_backslash_escape(&self) -> bool { 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: /// ```sql /// SELECT U&'\0061\0062\0063'; /// ``` /// This is equivalent to the string literal `'abc'`. /// See /// - [Postgres docs](https://www.postgresql.org/docs/current/sql-syntax-lexical.html#SQL-SYNTAX-STRINGS-UESCAPE) /// - [H2 docs](http://www.h2database.com/html/grammar.html#string) fn supports_unicode_string_literal(&self) -> bool { false } /// Does the dialect support `FILTER (WHERE expr)` for aggregate queries? fn supports_filter_during_aggregation(&self) -> bool { false } /// Returns true if the dialect supports referencing another named window /// within a window clause declaration. /// /// Example /// ```sql /// SELECT * FROM mytable /// WINDOW mynamed_window AS another_named_window /// ``` fn supports_window_clause_named_window_reference(&self) -> bool { false } /// Returns true if the dialect supports `ARRAY_AGG() [WITHIN GROUP (ORDER BY)]` expressions. /// Otherwise, the dialect should expect an `ORDER BY` without the `WITHIN GROUP` clause, e.g. [`ANSI`] /// /// [`ANSI`]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#array-aggregate-function fn supports_within_after_array_aggregation(&self) -> bool { false } /// Returns true if the dialect supports `PARTITION BY` appearing after `ORDER BY` /// in a `CREATE TABLE` statement (in addition to the standard placement before `ORDER BY`). /// /// ClickHouse DDL uses this ordering: /// fn supports_partition_by_after_order_by(&self) -> bool { false } /// Returns true if the dialect supports ClickHouse-style `ARRAY JOIN` / `LEFT ARRAY JOIN` / /// `INNER ARRAY JOIN` syntax for unnesting arrays inline. /// /// fn supports_array_join_syntax(&self) -> bool { false } /// Returns true if the dialects supports `group sets, roll up, or cube` expressions. fn supports_group_by_expr(&self) -> bool { 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 a join specification on CROSS JOIN. fn supports_cross_join_constraint(&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 } /// Returns true if the dialect supports `(NOT) IN ()` expressions fn supports_in_empty_list(&self) -> bool { false } /// Returns true if the dialect supports `BEGIN {DEFERRED | IMMEDIATE | EXCLUSIVE | TRY | CATCH} [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')`. 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. /// /// i.e The following syntax returns true /// ```sql /// FIRST_VALUE(a IGNORE NULLS) OVER () /// ``` /// while the following syntax returns false /// ```sql /// FIRST_VALUE(a) IGNORE NULLS OVER () /// ``` fn supports_window_function_null_treatment_arg(&self) -> bool { false } /// Returns true if the dialect supports defining structs or objects using a /// syntax like `{'x': 1, 'y': 2, 'z': 3}`. fn supports_dictionary_syntax(&self) -> bool { false } /// Returns true if the dialect supports defining object using the /// syntax like `Map {1: 10, 2: 20}`. fn support_map_literal_syntax(&self) -> bool { false } /// Returns true if the dialect supports lambda functions, for example: /// /// ```sql /// SELECT transform(array(1, 2, 3), x -> x + 1); -- returns [2,3,4] /// ``` fn supports_lambda_functions(&self) -> bool { false } /// Returns true if the dialect supports multiple variable assignment /// using parentheses in a `SET` variable declaration. /// /// ```sql /// SET (variable[, ...]) = (expression[, ...]); /// ``` fn supports_parenthesized_set_variables(&self) -> bool { 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 `ORDER BY` in `UPDATE` statements. /// /// ```sql /// UPDATE foo SET bar = false WHERE foo = true ORDER BY foo ASC; /// ``` /// See fn supports_update_order_by(&self) -> bool { false } /// Returns true if the dialect supports an `EXCEPT` clause following a /// wildcard in a select list. /// /// For example /// ```sql /// SELECT * EXCEPT order_id FROM orders; /// ``` fn supports_select_wildcard_except(&self) -> bool { false } /// Returns true if the dialect has a CONVERT function which accepts a type first /// and an expression second, e.g. `CONVERT(varchar, 1)` fn convert_type_before_value(&self) -> bool { false } /// Returns true if the dialect supports triple quoted string /// e.g. `"""abc"""` fn supports_triple_quoted_string(&self) -> bool { false } /// Dialect-specific prefix parser override fn parse_prefix(&self, _parser: &mut Parser) -> Option> { // return None to fall back to the default behavior None } /// Does the dialect support trailing commas around the query? fn supports_trailing_commas(&self) -> bool { false } /// Does the dialect support parsing `LIMIT 1, 2` as `LIMIT 2 OFFSET 1`? fn supports_limit_comma(&self) -> bool { false } /// Returns true if the dialect supports concatenating of string literal /// Example: `SELECT 'Hello ' "world" => SELECT 'Hello world'` fn supports_string_literal_concatenation(&self) -> bool { false } /// Returns true if the dialect supports concatenating string literals with a newline. /// For example, the following statement would return `true`: /// ```sql /// SELECT 'abc' in ( /// 'a' /// 'b' /// 'c' /// ); /// ``` fn supports_string_literal_concatenation_with_newline(&self) -> bool { false } /// Does the dialect support trailing commas in the projection list? fn supports_projection_trailing_commas(&self) -> bool { 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('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 "FROM-first" inserts. /// /// Example: /// ```sql /// WITH cte AS (SELECT key FROM src) /// FROM cte /// INSERT OVERWRITE table my_table /// SELECT * /// /// See /// ``` fn supports_from_first_insert(&self) -> bool { false } /// Return true if the dialect supports pipe operator. /// /// Example: /// ```sql /// SELECT * /// FROM table /// |> limit 1 /// ``` /// /// See 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 } /// Returns true if the dialect supports an exclude option /// following a wildcard in the projection section. For example: /// `SELECT * EXCLUDE col1 FROM tbl`. /// /// [Redshift](https://docs.aws.amazon.com/redshift/latest/dg/r_EXCLUDE_list.html) /// [Snowflake](https://docs.snowflake.com/en/sql-reference/sql/select) fn supports_select_wildcard_exclude(&self) -> bool { false } /// Returns true if the dialect supports an exclude option /// as the last item in the projection section, not necessarily /// after a wildcard. For example: /// `SELECT *, c1, c2 EXCLUDE c3 FROM tbl` /// /// [Redshift](https://docs.aws.amazon.com/redshift/latest/dg/r_EXCLUDE_list.html) fn supports_select_exclude(&self) -> bool { false } /// Returns true if the dialect supports specifying multiple options /// in a `CREATE TABLE` statement for the structure of the new table. For example: /// `CREATE TABLE t (a INT, b INT) AS SELECT 1 AS b, 2 AS a` fn supports_create_table_multi_schema_info_sources(&self) -> bool { false } /// Returns true if the dialect supports MySQL-specific SELECT modifiers /// like `HIGH_PRIORITY`, `STRAIGHT_JOIN`, `SQL_SMALL_RESULT`, etc. /// /// For example: /// ```sql /// SELECT HIGH_PRIORITY STRAIGHT_JOIN SQL_SMALL_RESULT * FROM t1 JOIN t2 ON ... /// ``` /// /// [MySQL](https://dev.mysql.com/doc/refman/8.4/en/select.html) fn supports_select_modifiers(&self) -> bool { false } /// Dialect-specific infix parser override /// /// This method is called to parse the next infix expression. /// /// If `None` is returned, falls back to the default behavior. fn parse_infix( &self, _parser: &mut Parser, _expr: &Expr, _precedence: u8, ) -> Option> { // return None to fall back to the default behavior None } /// Dialect-specific precedence override /// /// This method is called to get the precedence of the next token. /// /// If `None` is returned, falls back to the default behavior. fn get_next_precedence(&self, _parser: &Parser) -> Option> { // return None to fall back to the default behavior None } /// Get the precedence of the next token, looking at the full token stream. /// /// A higher number => higher precedence /// /// See [`Self::get_next_precedence`] to override the behavior for just the /// next token. /// /// The default implementation is used for many dialects, but can be /// overridden to provide dialect-specific behavior. fn get_next_precedence_default(&self, parser: &Parser) -> Result { if let Some(precedence) = self.get_next_precedence(parser) { return precedence; } macro_rules! p { ($precedence:ident) => { self.prec_value(Precedence::$precedence) }; } let token = parser.peek_token_ref(); 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)), Token::Word(w) if w.keyword == Keyword::XOR => Ok(p!(Xor)), Token::Word(w) if w.keyword == Keyword::AT => { match ( &parser.peek_nth_token_ref(1).token, &parser.peek_nth_token_ref(2).token, ) { (Token::Word(w), Token::Word(w2)) if w.keyword == Keyword::TIME && w2.keyword == Keyword::ZONE => { Ok(p!(AtTz)) } _ => Ok(self.prec_unknown()), } } Token::Word(w) if w.keyword == Keyword::NOT => { match &parser.peek_nth_token_ref(1).token { // The precedence of NOT varies depending on keyword that // follows it. If it is followed by IN, BETWEEN, or LIKE, // it takes on the precedence of those tokens. Otherwise, it // is not an infix operator, and therefore has zero // precedence. 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::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::NULL && !parser.in_column_definition_state() => { Ok(p!(Is)) } _ => Ok(self.prec_unknown()), } } Token::Word(w) if w.keyword == Keyword::NOTNULL && self.supports_notnull_operator() => { Ok(p!(Is)) } 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::Lt | Token::LtEq | Token::Neq | Token::Gt | Token::GtEq | Token::DoubleEq | Token::Tilde | Token::TildeAsterisk | Token::ExclamationMarkTilde | Token::ExclamationMarkTildeAsterisk | Token::DoubleTilde | Token::DoubleTildeAsterisk | 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::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::Colon => match &parser.peek_nth_token_ref(1).token { // When colon is followed by a string or a number, it's usually in MAP syntax. Token::SingleQuotedString(_) | Token::Number(_, _) => Ok(self.prec_unknown()), // In other cases, it's used in semi-structured data traversal like in variant or JSON // string columns. See `JsonAccess`. _ => Ok(p!(Colon)), }, Token::Arrow | Token::LongArrow | Token::HashArrow | Token::HashLongArrow | Token::AtArrow | Token::ArrowAt | Token::HashMinus | Token::AtQuestion | Token::AtAt | Token::Question | Token::QuestionAnd | Token::CustomBinaryOperator(_) => Ok(p!(PgOther)), _ => Ok(self.prec_unknown()), } } /// Dialect-specific statement parser override /// /// This method is called to parse the next statement. /// /// If `None` is returned, falls back to the default behavior. fn parse_statement(&self, _parser: &mut Parser) -> Option> { // return None to fall back to the default behavior None } /// Dialect-specific column option parser override /// /// This method is called to parse the next column option. /// /// If `None` is returned, falls back to the default behavior. fn parse_column_option( &self, _parser: &mut Parser, ) -> Result, ParserError>>, ParserError> { // return None to fall back to the default behavior Ok(None) } /// Decide the lexical Precedence of operators. /// /// Uses (APPROXIMATELY) as a reference fn prec_value(&self, prec: Precedence) -> u8 { match prec { Precedence::Period => 100, Precedence::DoubleColon => 50, Precedence::AtTz => 41, Precedence::MulDivModOp => 40, Precedence::PlusMinus => 30, Precedence::Xor => 24, Precedence::Ampersand => 23, Precedence::Caret => 22, Precedence::Pipe => 21, Precedence::Colon => 21, Precedence::Between => 20, Precedence::Eq => 20, Precedence::Like => 19, Precedence::Is => 17, Precedence::PgOther => 16, Precedence::UnaryNot => 15, Precedence::And => 10, Precedence::Or => 5, } } /// Returns the precedence when the precedence is otherwise unknown fn prec_unknown(&self) -> u8 { 0 } /// Returns true if this dialect requires the `TABLE` keyword after `DESCRIBE` /// /// Defaults to false. /// /// If true, the following statement is valid: `DESCRIBE TABLE my_table` /// If false, the following statements are valid: `DESCRIBE my_table` and `DESCRIBE table` fn describe_requires_table_keyword(&self) -> bool { false } /// Returns true if this dialect allows the `EXTRACT` function to words other than [`Keyword`]. fn allow_extract_custom(&self) -> bool { false } /// Returns true if this dialect allows the `EXTRACT` function to use single quotes in the part being extracted. fn allow_extract_single_quotes(&self) -> bool { false } /// Returns true if this dialect supports the `EXTRACT` function /// with a comma separator instead of `FROM`. /// /// Example: /// ```sql /// SELECT EXTRACT(YEAR, date_column) FROM table; /// ``` /// /// [Snowflake](https://docs.snowflake.com/en/sql-reference/functions/extract) fn supports_extract_comma_syntax(&self) -> bool { false } /// Returns true if this dialect supports a subquery passed to a function /// as the only argument without enclosing parentheses. /// /// Example: /// ```sql /// SELECT FLATTEN(SELECT * FROM tbl); /// ``` /// /// [Snowflake](https://docs.snowflake.com/en/sql-reference/functions/flatten) fn supports_subquery_as_function_arg(&self) -> bool { false } /// Returns true if this dialect supports the `COMMENT` clause in /// `CREATE VIEW` statements using the `COMMENT = 'comment'` syntax. /// /// Example: /// ```sql /// CREATE VIEW v COMMENT = 'my comment' AS SELECT 1; /// ``` /// /// [Snowflake](https://docs.snowflake.com/en/sql-reference/sql/create-view#optional-parameters) fn supports_create_view_comment_syntax(&self) -> bool { false } /// Returns true if this dialect supports the `ARRAY` type without /// specifying an element type. /// /// Example: /// ```sql /// CREATE TABLE t (a ARRAY); /// ``` /// /// [Snowflake](https://docs.snowflake.com/en/sql-reference/data-types-semistructured#array) fn supports_array_typedef_without_element_type(&self) -> bool { false } /// Returns true if this dialect supports extra parentheses around /// lone table names or derived tables in the `FROM` clause. /// /// Example: /// ```sql /// SELECT * FROM (mytable); /// SELECT * FROM ((SELECT 1)); /// SELECT * FROM (mytable) AS alias; /// ``` /// /// [Snowflake](https://docs.snowflake.com/en/sql-reference/constructs/from) fn supports_parens_around_table_factor(&self) -> bool { false } /// Returns true if this dialect supports `VALUES` as a table factor /// without requiring parentheses around the entire clause. /// /// Example: /// ```sql /// SELECT * FROM VALUES (1, 'a'), (2, 'b') AS t (col1, col2); /// ``` /// /// [Snowflake](https://docs.snowflake.com/en/sql-reference/constructs/values) /// [Databricks](https://docs.databricks.com/en/sql/language-manual/sql-ref-syntax-qry-select-values.html) fn supports_values_as_table_factor(&self) -> bool { false } /// Returns true if this dialect allows dollar placeholders /// e.g. `SELECT $var` (SQLite) fn supports_dollar_placeholder(&self) -> bool { false } /// Returns true if this dialect supports `$` as a prefix for money literals /// e.g. `SELECT $123.45` (SQL Server) fn supports_dollar_as_money_prefix(&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 { false } /// Whether `INTERVAL` expressions require units (called "qualifiers" in the ANSI SQL spec) to be specified, /// e.g. `INTERVAL 1 DAY` vs `INTERVAL 1`. /// /// Expressions within intervals (e.g. `INTERVAL '1' + '1' DAY`) are only allowed when units are required. /// /// See for more information. /// /// When `true`: /// * `INTERVAL '1' DAY` is VALID /// * `INTERVAL 1 + 1 DAY` is VALID /// * `INTERVAL '1' + '1' DAY` is VALID /// * `INTERVAL '1'` is INVALID /// /// When `false`: /// * `INTERVAL '1'` is VALID /// * `INTERVAL '1' DAY` is VALID — unit is not required, but still allowed /// * `INTERVAL 1 + 1 DAY` is INVALID fn require_interval_qualifier(&self) -> bool { false } /// Returns true if the dialect supports `EXPLAIN` statements with utility options /// e.g. `EXPLAIN (ANALYZE TRUE, BUFFERS TRUE) SELECT * FROM tbl;` fn supports_explain_with_utility_options(&self) -> bool { false } /// Returns true if the dialect supports `ASC` and `DESC` in column definitions /// e.g. `CREATE TABLE t (a INT ASC, b INT DESC);` fn supports_asc_desc_in_column_definition(&self) -> bool { false } /// Returns true if the dialect supports `a!` expressions fn supports_factorial_operator(&self) -> bool { false } /// Returns true if the dialect supports `<<` and `>>` shift operators. fn supports_bitwise_shift_operators(&self) -> bool { false } /// Returns true if the dialect supports nested comments /// e.g. `/* /* nested */ */` fn supports_nested_comments(&self) -> bool { false } /// Returns true if the dialect supports optimizer hints in multiline comments /// e.g. `/*!50110 KEY_BLOCK_SIZE = 1024*/` fn supports_multiline_comment_hints(&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: /// ```sql /// SELECT col_alias = col FROM tbl; /// SELECT col_alias AS col FROM tbl; /// ``` fn supports_eq_alias_assignment(&self) -> bool { false } /// Returns true if this dialect supports the `TRY_CONVERT` function fn supports_try_convert(&self) -> bool { false } /// Returns true if the dialect supports `!a` syntax for boolean `NOT` expressions. fn supports_bang_not_operator(&self) -> bool { false } /// Returns true if the dialect supports the `LISTEN`, `UNLISTEN` and `NOTIFY` statements fn supports_listen_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 /// 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 /// fn supports_partiql(&self) -> bool { false } /// Returns true if the dialect supports the `CONSTRAINT` keyword without a name /// in table constraint definitions. /// /// Example: /// ```sql /// CREATE TABLE t (a INT, CONSTRAINT CHECK (a > 0)) /// ``` /// /// This is a MySQL extension; the SQL standard requires a name after `CONSTRAINT`. /// When the name is omitted, the output normalizes to just the constraint type /// without the `CONSTRAINT` keyword (e.g., `CHECK (a > 0)`). /// /// fn supports_constraint_keyword_without_name(&self) -> bool { false } /// Returns true if the dialect supports the `KEY` keyword as part of /// column-level constraints in a `CREATE TABLE` statement. /// /// When enabled, the parser accepts these MySQL-specific column options: /// - `UNIQUE [KEY]` — optional `KEY` after `UNIQUE` /// - `[PRIMARY] KEY` — standalone `KEY` as shorthand for `PRIMARY KEY` /// /// fn supports_key_column_option(&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 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` /// /// fn supports_table_sample_before_alias(&self) -> bool { false } /// Returns true if this dialect supports the `INSERT INTO ... SET col1 = 1, ...` syntax. /// /// MySQL: 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 table queries in insertion? /// /// e.g. `SELECT INTO () ...` fn supports_insert_table_query(&self) -> bool { false } /// Does the dialect support insert formats, e.g. `INSERT INTO ... FORMAT ` fn supports_insert_format(&self) -> bool { false } /// Returns true if this dialect supports `INSERT INTO t [[AS] alias] ...`. fn supports_insert_table_alias(&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 identifier. /// See [keywords::RESERVED_FOR_TABLE_FACTOR] fn is_table_factor(&self, kw: &Keyword, _parser: &mut Parser) -> bool { !keywords::RESERVED_FOR_TABLE_FACTOR.contains(kw) } /// Returns true if the specified keyword should be parsed as a table factor alias. /// See [keywords::RESERVED_FOR_TABLE_ALIAS] fn is_table_alias(&self, kw: &Keyword, _parser: &mut Parser) -> bool { !keywords::RESERVED_FOR_TABLE_ALIAS.contains(kw) } /// 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 || self.is_table_alias(kw, parser) } /// Returns true if this dialect supports querying historical table data /// by specifying which version of the data to query. fn supports_table_versioning(&self) -> bool { false } /// Returns true if this dialect supports the E'...' syntax for string literals /// /// Postgres: 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: /// 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: /// 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 [COLLATE ]`. /// /// - [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 } /// Returns true if the dialect supports space-separated column options /// in a `CREATE TABLE` statement. For example: /// ```sql /// CREATE TABLE tbl ( /// col INT NOT NULL DEFAULT 0 /// ); /// ``` 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 USING ` /// ``` 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 } /// Returns true if the dialect considers the specified ident as a function /// that returns an identifier. Typically used to generate identifiers /// programmatically. /// /// - [Snowflake](https://docs.snowflake.com/en/sql-reference/identifier-literal) fn is_identifier_generating_function_name( &self, _ident: &Ident, _name_parts: &[ObjectNamePart], ) -> bool { false } /// Returns true if the dialect supports the `x NOTNULL` /// operator expression. fn supports_notnull_operator(&self) -> bool { false } /// Returns true if this dialect allows an optional `SIGNED` suffix after integer data types. /// /// Example: /// ```sql /// CREATE TABLE t (i INT(20) SIGNED); /// ``` /// /// Note that this is canonicalized to `INT(20)`. fn supports_data_type_signed_suffix(&self) -> bool { false } /// Returns true if the dialect supports the `INTERVAL` data type with [Postgres]-style options. /// /// Examples: /// ```sql /// CREATE TABLE t (i INTERVAL YEAR TO MONTH); /// SELECT '1 second'::INTERVAL HOUR TO SECOND(3); /// ``` /// /// See [`crate::ast::DataType::Interval`] and [`crate::ast::IntervalFields`]. /// /// [Postgres]: https://www.postgresql.org/docs/17/datatype-datetime.html fn supports_interval_options(&self) -> bool { false } /// Returns true if the dialect supports specifying which table to copy /// the schema from inside parenthesis. /// /// Not parenthesized: /// '''sql /// CREATE TABLE new LIKE old ... /// ''' /// [Snowflake](https://docs.snowflake.com/en/sql-reference/sql/create-table#label-create-table-like) /// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language#create_table_like) /// /// Parenthesized: /// '''sql /// CREATE TABLE new (LIKE old ...) /// ''' /// [Redshift](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_TABLE_NEW.html) fn supports_create_table_like_parenthesized(&self) -> bool { false } /// Returns true if the dialect supports `SEMANTIC_VIEW()` table functions. /// /// ```sql /// SELECT * FROM SEMANTIC_VIEW( /// model_name /// DIMENSIONS customer.name, customer.region /// METRICS orders.revenue, orders.count /// WHERE customer.active = true /// ) /// ``` fn supports_semantic_view_table_factor(&self) -> bool { false } /// Support quote delimited string literals, e.g. `Q'{...}'` /// /// [Oracle](https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/Literals.html#GUID-1824CBAA-6E16-4921-B2A6-112FB02248DA) fn supports_quote_delimited_string(&self) -> bool { false } /// Returns `true` if the dialect supports query optimizer hints in the /// format of single and multi line comments immediately following a /// `SELECT`, `INSERT`, `REPLACE`, `DELETE`, or `MERGE` keyword. /// /// [MySQL](https://dev.mysql.com/doc/refman/8.4/en/optimizer-hints.html) /// [Oracle](https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/Comments.html#SQLRF-GUID-D316D545-89E2-4D54-977F-FC97815CD62E) fn supports_comment_optimizer_hint(&self) -> bool { false } /// Returns true if the dialect considers the `&&` operator as a boolean AND operator. fn supports_double_ampersand_operator(&self) -> bool { false } /// Returns true if the dialect supports casting an expression to a binary type /// using the `BINARY ` syntax. fn supports_binary_kw_as_cast(&self) -> bool { false } /// Returns true if this dialect supports the `REPLACE` option in a /// `SELECT *` wildcard expression. /// /// Example: /// ```sql /// SELECT * REPLACE (col1 AS col1_alias) FROM table; /// ``` /// /// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/query-syntax#select_replace) /// [ClickHouse](https://clickhouse.com/docs/sql-reference/statements/select#replace) /// [DuckDB](https://duckdb.org/docs/sql/query_syntax/select#replace-clause) /// [Snowflake](https://docs.snowflake.com/en/sql-reference/sql/select#parameters) fn supports_select_wildcard_replace(&self) -> bool { false } /// Returns true if this dialect supports the `ILIKE` option in a /// `SELECT *` wildcard expression. /// /// Example: /// ```sql /// SELECT * ILIKE '%pattern%' FROM table; /// ``` /// /// [Snowflake](https://docs.snowflake.com/en/sql-reference/sql/select#parameters) fn supports_select_wildcard_ilike(&self) -> bool { false } /// Returns true if this dialect supports the `RENAME` option in a /// `SELECT *` wildcard expression. /// /// Example: /// ```sql /// SELECT * RENAME col1 AS col1_alias FROM table; /// ``` /// /// [Snowflake](https://docs.snowflake.com/en/sql-reference/sql/select#parameters) fn supports_select_wildcard_rename(&self) -> bool { false } /// Returns true if this dialect supports aliasing a wildcard select item. /// /// Example: /// ```sql /// SELECT t.* alias FROM t /// SELECT t.* AS alias FROM t /// ``` fn supports_select_wildcard_with_alias(&self) -> bool { false } /// Returns true if this dialect supports the `OPTIMIZE TABLE` statement. /// /// Example: /// ```sql /// OPTIMIZE TABLE table_name; /// ``` /// /// [ClickHouse](https://clickhouse.com/docs/en/sql-reference/statements/optimize) fn supports_optimize_table(&self) -> bool { false } /// Returns true if this dialect supports the `INSTALL` statement. /// /// Example: /// ```sql /// INSTALL extension_name; /// ``` /// /// [DuckDB](https://duckdb.org/docs/extensions/overview) fn supports_install(&self) -> bool { false } /// Returns true if this dialect supports the `DETACH` statement. /// /// Example: /// ```sql /// DETACH DATABASE db_name; /// ``` /// /// [DuckDB](https://duckdb.org/docs/sql/statements/attach#detach-syntax) fn supports_detach(&self) -> bool { false } /// Returns true if this dialect supports the `PREWHERE` clause /// in `SELECT` statements. /// /// Example: /// ```sql /// SELECT * FROM table PREWHERE col > 0 WHERE col < 100; /// ``` /// /// [ClickHouse](https://clickhouse.com/docs/en/sql-reference/statements/select/prewhere) fn supports_prewhere(&self) -> bool { false } /// Returns true if this dialect supports the `WITH FILL` clause /// in `ORDER BY` expressions. /// /// Example: /// ```sql /// SELECT * FROM table ORDER BY col WITH FILL FROM 1 TO 10 STEP 1; /// ``` /// /// [ClickHouse](https://clickhouse.com/docs/en/sql-reference/statements/select/order-by#order-by-expr-with-fill-modifier) fn supports_with_fill(&self) -> bool { false } /// Returns true if this dialect supports the `LIMIT BY` clause. /// /// Example: /// ```sql /// SELECT * FROM table LIMIT 10 BY col; /// ``` /// /// [ClickHouse](https://clickhouse.com/docs/en/sql-reference/statements/select/limit-by) fn supports_limit_by(&self) -> bool { false } /// Returns true if this dialect supports the `INTERPOLATE` clause /// in `ORDER BY` expressions. /// /// Example: /// ```sql /// SELECT * FROM table ORDER BY col WITH FILL INTERPOLATE (col2 AS col2 + 1); /// ``` /// /// [ClickHouse](https://clickhouse.com/docs/en/sql-reference/statements/select/order-by#order-by-expr-with-fill-modifier) fn supports_interpolate(&self) -> bool { false } /// Returns true if this dialect supports the `SETTINGS` clause. /// /// Example: /// ```sql /// SELECT * FROM table SETTINGS max_threads = 4; /// ``` /// /// [ClickHouse](https://clickhouse.com/docs/en/sql-reference/statements/select#settings-in-select-query) fn supports_settings(&self) -> bool { false } /// Returns true if this dialect supports the `FORMAT` clause in `SELECT` statements. /// /// Example: /// ```sql /// SELECT * FROM table FORMAT JSON; /// ``` /// /// [ClickHouse](https://clickhouse.com/docs/en/sql-reference/statements/select/format) fn supports_select_format(&self) -> bool { false } /// Returns true if the dialect supports the two-argument comma-separated /// form of the `TRIM` function: `TRIM(expr, characters)`. fn supports_comma_separated_trim(&self) -> bool { false } /// Returns true if the dialect supports the `AS` keyword being /// optional in a CTE definition. For example: /// ```sql /// WITH cte_name (SELECT ...) /// ``` /// /// [Databricks](https://docs.databricks.com/aws/en/sql/language-manual/sql-ref-syntax-qry-select-cte) fn supports_cte_without_as(&self) -> bool { false } /// Returns true if the dialect supports parenthesized multi-column /// aliases in SELECT items. For example: /// ```sql /// SELECT stack(2, 'a', 'b') AS (col1, col2) /// ``` /// /// [Spark SQL](https://spark.apache.org/docs/latest/sql-ref-syntax-qry-select.html) fn supports_select_item_multi_column_alias(&self) -> bool { false } /// Returns true if the dialect supports XML-related expressions /// such as `xml ''` typed strings, XML functions like /// `XMLCONCAT`, `XMLELEMENT`, etc. /// /// When this returns false, `xml` is treated as a regular identifier. /// /// [PostgreSQL](https://www.postgresql.org/docs/current/functions-xml.html) fn supports_xml_expressions(&self) -> bool { false } /// Returns true if the dialect supports `USING ` in `CREATE TABLE`. /// /// Example: /// ```sql /// CREATE TABLE t (i INT) USING PARQUET /// ``` /// /// [Spark SQL](https://spark.apache.org/docs/latest/sql-ref-syntax-ddl-create-table-datasource.html) fn supports_create_table_using(&self) -> bool { false } /// Returns true if the dialect treats `LONG` as an alias for `BIGINT`. /// /// Example: /// ```sql /// CREATE TABLE t (id LONG) /// ``` /// /// [Spark SQL](https://spark.apache.org/docs/latest/sql-ref-datatypes.html) fn supports_long_type_as_bigint(&self) -> bool { false } /// Returns true if the dialect supports `MAP` angle-bracket syntax for the MAP data type. /// /// Example: /// ```sql /// CREATE TABLE t (m MAP) /// ``` /// /// [Spark SQL](https://spark.apache.org/docs/latest/sql-ref-datatypes.html) fn supports_map_literal_with_angle_brackets(&self) -> bool { false } } /// Operators for which precedence must be defined. /// /// Higher number -> higher precedence. /// See expression parsing for how these values are used. #[derive(Debug, Clone, Copy)] pub enum Precedence { /// Member access operator `.` (highest precedence). Period, /// Postgres style type cast `::`. DoubleColon, /// Timezone operator (e.g. `AT TIME ZONE`). AtTz, /// Multiplication / Division / Modulo operators (`*`, `/`, `%`). MulDivModOp, /// Addition / Subtraction (`+`, `-`). PlusMinus, /// Bitwise `XOR` operator (`^`). Xor, /// Bitwise `AND` operator (`&`). Ampersand, /// Bitwise `CARET` (^) for some dialects. Caret, /// Bitwise `OR` / pipe operator (`|`). Pipe, /// `:` operator for json/variant access. Colon, /// `BETWEEN` operator. Between, /// Equality operator (`=`). Eq, /// Pattern matching (`LIKE`). Like, /// `IS` operator (e.g. `IS NULL`). Is, /// Other Postgres-specific operators. PgOther, /// Unary `NOT`. UnaryNot, /// Logical `AND`. And, /// Logical `OR` (lowest precedence). Or, } impl dyn Dialect { /// Returns true if `self` is the concrete dialect `T`. #[inline] pub fn is(&self) -> bool { // borrowed from `Any` implementation TypeId::of::() == self.dialect() } } /// Returns the built in [`Dialect`] corresponding to `dialect_name`. /// /// See [`Dialect`] documentation for an example. pub fn dialect_from_str(dialect_name: impl AsRef) -> Option> { let dialect_name = dialect_name.as_ref(); match dialect_name.to_lowercase().as_str() { "generic" => Some(Box::new(GenericDialect)), "mysql" => Some(Box::new(MySqlDialect {})), "postgresql" | "postgres" => Some(Box::new(PostgreSqlDialect {})), "hive" => Some(Box::new(HiveDialect {})), "sqlite" => Some(Box::new(SQLiteDialect {})), "snowflake" => Some(Box::new(SnowflakeDialect)), "redshift" => Some(Box::new(RedshiftSqlDialect {})), "mssql" => Some(Box::new(MsSqlDialect {})), "clickhouse" => Some(Box::new(ClickHouseDialect {})), "bigquery" => Some(Box::new(BigQueryDialect)), "ansi" => Some(Box::new(AnsiDialect {})), "duckdb" => Some(Box::new(DuckDbDialect {})), "databricks" => Some(Box::new(DatabricksDialect {})), "spark" | "sparksql" => Some(Box::new(SparkSqlDialect {})), "oracle" => Some(Box::new(OracleDialect {})), "teradata" => Some(Box::new(TeradataDialect {})), _ => None, } } #[cfg(test)] mod tests { use super::*; struct DialectHolder<'a> { dialect: &'a dyn Dialect, } #[test] fn test_is_dialect() { let generic_dialect: &dyn Dialect = &GenericDialect {}; let ansi_dialect: &dyn Dialect = &AnsiDialect {}; let generic_holder = DialectHolder { dialect: generic_dialect, }; let ansi_holder = DialectHolder { dialect: ansi_dialect, }; assert!(dialect_of!(generic_holder is GenericDialect | AnsiDialect),); assert!(!dialect_of!(generic_holder is AnsiDialect)); assert!(dialect_of!(ansi_holder is AnsiDialect)); assert!(dialect_of!(ansi_holder is GenericDialect | AnsiDialect)); assert!(!dialect_of!(ansi_holder is GenericDialect | MsSqlDialect)); } #[test] fn test_dialect_from_str() { assert!(parse_dialect("generic").is::()); assert!(parse_dialect("mysql").is::()); assert!(parse_dialect("MySql").is::()); assert!(parse_dialect("postgresql").is::()); assert!(parse_dialect("postgres").is::()); assert!(parse_dialect("hive").is::()); assert!(parse_dialect("sqlite").is::()); assert!(parse_dialect("snowflake").is::()); assert!(parse_dialect("SnowFlake").is::()); assert!(parse_dialect("MsSql").is::()); assert!(parse_dialect("clickhouse").is::()); assert!(parse_dialect("ClickHouse").is::()); assert!(parse_dialect("bigquery").is::()); assert!(parse_dialect("BigQuery").is::()); assert!(parse_dialect("ansi").is::()); assert!(parse_dialect("ANSI").is::()); assert!(parse_dialect("duckdb").is::()); assert!(parse_dialect("DuckDb").is::()); assert!(parse_dialect("DataBricks").is::()); assert!(parse_dialect("databricks").is::()); assert!(parse_dialect("teradata").is::()); assert!(parse_dialect("Teradata").is::()); // error cases assert!(dialect_from_str("Unknown").is_none()); assert!(dialect_from_str("").is_none()); } fn parse_dialect(v: &str) -> Box { dialect_from_str(v).unwrap() } #[test] #[cfg(feature = "derive-dialect")] fn test_dialect_override() { derive_dialect!(EnhancedGenericDialect, GenericDialect, preserve_type_id = true, overrides = { supports_order_by_all = true, supports_nested_comments = true, supports_triple_quoted_string = true, }, ); let dialect = EnhancedGenericDialect::new(); assert!(dialect.supports_order_by_all()); assert!(dialect.supports_nested_comments()); assert!(dialect.supports_triple_quoted_string()); let d: &dyn Dialect = &dialect; assert!(d.is::()); } #[test] fn identifier_quote_style() { let tests: Vec<(&dyn Dialect, &str, Option)> = vec![ (&GenericDialect {}, "id", None), (&SQLiteDialect {}, "id", Some('`')), (&PostgreSqlDialect {}, "id", Some('"')), ]; for (dialect, ident, expected) in tests { let actual = dialect.identifier_quote_style(ident); assert_eq!(actual, expected); } } #[test] fn parse_with_wrapped_dialect() { /// Wrapper for a dialect. In a real-world example, this wrapper /// would tweak the behavior of the dialect. For the test case, /// it wraps all methods unaltered. #[derive(Debug)] struct WrappedDialect(MySqlDialect); impl Dialect for WrappedDialect { fn dialect(&self) -> std::any::TypeId { self.0.dialect() } fn is_identifier_start(&self, ch: char) -> bool { self.0.is_identifier_start(ch) } fn is_delimited_identifier_start(&self, ch: char) -> bool { 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>, ) -> Option<(char, Option)> { self.0.peek_nested_delimited_identifier_quotes(chars) } fn identifier_quote_style(&self, identifier: &str) -> Option { self.0.identifier_quote_style(identifier) } fn supports_string_literal_backslash_escape(&self) -> bool { self.0.supports_string_literal_backslash_escape() } fn supports_filter_during_aggregation(&self) -> bool { self.0.supports_filter_during_aggregation() } fn supports_within_after_array_aggregation(&self) -> bool { self.0.supports_within_after_array_aggregation() } fn supports_group_by_expr(&self) -> bool { self.0.supports_group_by_expr() } fn supports_in_empty_list(&self) -> bool { self.0.supports_in_empty_list() } fn convert_type_before_value(&self) -> bool { self.0.convert_type_before_value() } fn parse_prefix( &self, parser: &mut sqlparser::parser::Parser, ) -> Option> { self.0.parse_prefix(parser) } fn parse_infix( &self, parser: &mut sqlparser::parser::Parser, expr: &Expr, precedence: u8, ) -> Option> { self.0.parse_infix(parser, expr, precedence) } fn get_next_precedence( &self, parser: &sqlparser::parser::Parser, ) -> Option> { self.0.get_next_precedence(parser) } fn parse_statement( &self, parser: &mut sqlparser::parser::Parser, ) -> Option> { self.0.parse_statement(parser) } fn is_identifier_part(&self, ch: char) -> bool { self.0.is_identifier_part(ch) } } #[allow(clippy::needless_raw_string_hashes)] let statement = r#"SELECT 'Wayne\'s World'"#; let res1 = Parser::parse_sql(&MySqlDialect {}, statement); let res2 = Parser::parse_sql(&WrappedDialect(MySqlDialect {}), statement); assert!(res1.is_ok()); assert_eq!(res1, res2); } } apache-datafusion-sqlparser-rs-0.62.0/src/dialect/mssql.rs000066400000000000000000000345721517524037000235270ustar00rootroot00000000000000// 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 crate::ast::helpers::attached_token::AttachedToken; use crate::ast::{ BeginEndStatements, ConditionalStatementBlock, ConditionalStatements, CreateTrigger, GranteesType, IfStatement, Statement, }; use crate::dialect::Dialect; use crate::keywords::Keyword; use crate::parser::{Parser, ParserError}; use crate::tokenizer::Token; #[cfg(not(feature = "std"))] use alloc::{vec, vec::Vec}; /// A [`Dialect`] for [Microsoft SQL Server](https://www.microsoft.com/en-us/sql-server/) #[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct MsSqlDialect {} impl Dialect for MsSqlDialect { fn is_delimited_identifier_start(&self, ch: char) -> bool { ch == '"' || ch == '[' } fn is_identifier_start(&self, ch: char) -> bool { // See https://docs.microsoft.com/en-us/sql/relational-databases/databases/database-identifiers?view=sql-server-2017#rules-for-regular-identifiers ch.is_alphabetic() || ch == '_' || ch == '#' || ch == '@' } fn is_identifier_part(&self, ch: char) -> bool { ch.is_alphabetic() || ch.is_ascii_digit() || ch == '@' || ch == '$' || ch == '#' || ch == '_' } fn identifier_quote_style(&self, _identifier: &str) -> Option { Some('[') } /// SQL Server has `CONVERT(type, value)` instead of `CONVERT(value, type)` /// fn convert_type_before_value(&self) -> bool { true } fn supports_outer_join_operator(&self) -> bool { true } /// SQL Server supports `$` as a prefix for money literals /// fn supports_dollar_as_money_prefix(&self) -> bool { true } fn supports_connect_by(&self) -> bool { true } fn supports_eq_alias_assignment(&self) -> bool { true } 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: fn supports_set_stmt_without_operator(&self) -> bool { true } /// See: fn supports_table_versioning(&self) -> bool { true } /// See fn supports_nested_comments(&self) -> bool { true } /// See fn supports_object_name_double_dot_notation(&self) -> bool { true } /// See fn get_reserved_grantees_types(&self) -> &[GranteesType] { &[GranteesType::Public] } fn is_select_item_alias(&self, explicit: bool, kw: &Keyword, parser: &mut Parser) -> bool { match kw { // List of keywords that cannot be used as select item (column) aliases in MSSQL // regardless of whether the alias is explicit or implicit. // // These are T-SQL statement-starting keywords; allowing them as implicit aliases // causes the parser to consume the keyword as an alias for the previous expression, // then fail on the token that follows (e.g. `TABLE`, `@var`, `sp_name`, …). Keyword::IF | Keyword::ELSE | Keyword::DECLARE | Keyword::EXEC | Keyword::EXECUTE | Keyword::INSERT | Keyword::UPDATE | Keyword::DELETE | Keyword::DROP | Keyword::CREATE | Keyword::ALTER | Keyword::TRUNCATE | Keyword::PRINT | Keyword::WHILE | Keyword::RETURN | Keyword::THROW | Keyword::RAISERROR | Keyword::MERGE => false, _ => explicit || self.is_column_alias(kw, parser), } } fn is_table_factor_alias(&self, explicit: bool, kw: &Keyword, parser: &mut Parser) -> bool { match kw { // List of keywords that cannot be used as table aliases in MSSQL // regardless of whether the alias is explicit or implicit. // // These are T-SQL statement-starting keywords. Without blocking them here, // a bare `SELECT * FROM t` followed by a newline and one of these keywords // would cause the parser to consume the keyword as a table alias for `t`, // then fail on the token that follows (e.g. `@var`, `sp_name`, `TABLE`, …). // // `SET` is already covered by the global `RESERVED_FOR_TABLE_ALIAS` list; // the keywords below are MSSQL-specific additions. Keyword::IF | Keyword::ELSE | Keyword::DECLARE | Keyword::EXEC | Keyword::EXECUTE | Keyword::INSERT | Keyword::UPDATE | Keyword::DELETE | Keyword::DROP | Keyword::CREATE | Keyword::ALTER | Keyword::TRUNCATE | Keyword::PRINT | Keyword::WHILE | Keyword::RETURN | Keyword::THROW | Keyword::RAISERROR | Keyword::MERGE => false, _ => explicit || self.is_table_alias(kw, parser), } } fn parse_statement(&self, parser: &mut Parser) -> Option> { if parser.parse_keyword(Keyword::BEGIN) { // Check if this is a BEGIN...END block rather than BEGIN TRANSACTION let is_block = parser .maybe_parse(|p| { if p.parse_transaction_modifier().is_some() || p.parse_one_of_keywords(&[ Keyword::TRANSACTION, Keyword::WORK, Keyword::TRAN, ]) .is_some() || matches!(p.peek_token_ref().token, Token::SemiColon | Token::EOF) { p.expected_ref("statement", p.peek_token_ref()) } else { Ok(()) } }) .unwrap_or(None) .is_some(); if is_block { Some(parser.parse_begin_exception_end()) } else { parser.prev_token(); None } } else 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 } } fn get_next_precedence(&self, parser: &Parser) -> Option> { let token = parser.peek_token_ref(); match &token.token { // lowest prec to prevent it from turning into a binary op Token::Colon => Some(Ok(self.prec_unknown())), _ => 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 { 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(IfStatement { if_block, else_block, elseif_blocks: Vec::new(), end_token: None, } .into()) } /// 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 { 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(CreateTrigger { or_alter, temporary: false, or_replace: false, is_constraint: false, name, period: Some(period), period_before_table: false, events, table_name, referenced_table_name: None, referencing: Vec::new(), trigger_object: None, condition: None, exec_body: None, statements_as: true, statements, characteristics: None, } .into()) } /// 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, ) -> Result, 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) } } apache-datafusion-sqlparser-rs-0.62.0/src/dialect/mysql.rs000066400000000000000000000174711517524037000235340ustar00rootroot00000000000000// 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. #[cfg(not(feature = "std"))] use alloc::boxed::Box; use crate::{ ast::{BinaryOperator, Expr, LockTable, LockTableType, Statement}, dialect::Dialect, keywords::Keyword, 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, Default, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct MySqlDialect {} impl Dialect for MySqlDialect { fn is_identifier_start(&self, ch: char) -> bool { // See https://dev.mysql.com/doc/refman/8.0/en/identifiers.html. // Identifiers which begin with a digit are recognized while tokenizing numbers, // so they can be distinguished from exponent numeric literals. // MySQL also implements non ascii utf-8 charecters ch.is_alphabetic() || ch == '_' || ch == '$' || ch == '@' || ('\u{0080}'..='\u{ffff}').contains(&ch) || !ch.is_ascii() } fn is_identifier_part(&self, ch: char) -> bool { self.is_identifier_start(ch) || ch.is_ascii_digit() || // MySQL implements Unicode characters in identifiers. !ch.is_ascii() } fn is_delimited_identifier_start(&self, ch: char) -> bool { ch == '`' } fn identifier_quote_style(&self, _identifier: &str) -> Option { Some('`') } // See https://dev.mysql.com/doc/refman/8.0/en/string-literals.html#character-escape-sequences fn supports_string_literal_backslash_escape(&self) -> bool { true } /// see fn supports_string_literal_concatenation(&self) -> bool { true } fn ignores_wildcard_escapes(&self) -> bool { true } fn supports_numeric_prefix(&self) -> bool { true } fn supports_bitwise_shift_operators(&self) -> bool { true } /// see fn supports_multiline_comment_hints(&self) -> bool { true } fn parse_infix( &self, parser: &mut crate::parser::Parser, expr: &crate::ast::Expr, _precedence: u8, ) -> Option> { // Parse DIV as an operator if parser.parse_keyword(Keyword::DIV) { let left = Box::new(expr.clone()); let right = Box::new(match parser.parse_expr() { Ok(expr) => expr, Err(e) => return Some(Err(e)), }); Some(Ok(Expr::BinaryOp { left, op: BinaryOperator::MyIntegerDivide, right, })) } else { None } } fn parse_statement(&self, parser: &mut Parser) -> Option> { if parser.parse_keywords(&[Keyword::LOCK, Keyword::TABLES]) { Some(parse_lock_tables(parser)) } else if parser.parse_keywords(&[Keyword::UNLOCK, Keyword::TABLES]) { Some(parse_unlock_tables(parser)) } else { None } } fn require_interval_qualifier(&self) -> bool { true } fn supports_limit_comma(&self) -> bool { true } /// See: fn supports_create_table_select(&self) -> bool { true } /// See: 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_select_modifiers(&self) -> bool { true } fn supports_set_names(&self) -> bool { true } fn supports_comma_separated_set_assignments(&self) -> bool { true } /// See: fn supports_update_order_by(&self) -> bool { true } fn supports_data_type_signed_suffix(&self) -> bool { true } fn supports_cross_join_constraint(&self) -> bool { true } /// See: fn supports_double_ampersand_operator(&self) -> bool { true } /// Deprecated functionality by MySQL but still supported /// See: fn supports_binary_kw_as_cast(&self) -> bool { true } fn supports_comment_optimizer_hint(&self) -> bool { true } /// See: fn supports_constraint_keyword_without_name(&self) -> bool { true } /// See: fn supports_key_column_option(&self) -> bool { true } } /// `LOCK TABLES` /// fn parse_lock_tables(parser: &mut Parser) -> Result { let tables = parser.parse_comma_separated(parse_lock_table)?; Ok(Statement::LockTables { tables }) } // tbl_name [[AS] alias] lock_type fn parse_lock_table(parser: &mut Parser) -> Result { let table = parser.parse_identifier()?; let alias = parser.parse_optional_alias(&[Keyword::READ, Keyword::WRITE, Keyword::LOW_PRIORITY])?; let lock_type = parse_lock_tables_type(parser)?; Ok(LockTable { table, alias, lock_type, }) } // READ [LOCAL] | [LOW_PRIORITY] WRITE fn parse_lock_tables_type(parser: &mut Parser) -> Result { if parser.parse_keyword(Keyword::READ) { if parser.parse_keyword(Keyword::LOCAL) { Ok(LockTableType::Read { local: true }) } else { Ok(LockTableType::Read { local: false }) } } else if parser.parse_keyword(Keyword::WRITE) { Ok(LockTableType::Write { low_priority: false, }) } else if parser.parse_keywords(&[Keyword::LOW_PRIORITY, Keyword::WRITE]) { Ok(LockTableType::Write { low_priority: true }) } else { parser.expected_ref("an lock type in LOCK TABLES", parser.peek_token_ref()) } } /// UNLOCK TABLES /// fn parse_unlock_tables(_parser: &mut Parser) -> Result { Ok(Statement::UnlockTables) } apache-datafusion-sqlparser-rs-0.62.0/src/dialect/oracle.rs000066400000000000000000000066051517524037000236310ustar00rootroot00000000000000// 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 log::debug; use crate::{ parser::{Parser, ParserError}, tokenizer::Token, }; use super::{keywords::Keyword, Dialect, Precedence}; const RESERVED_KEYWORDS_FOR_SELECT_ITEM_OPERATOR: [Keyword; 1] = [Keyword::CONNECT_BY_ROOT]; /// A [`Dialect`] for [Oracle Databases](https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/index.html) #[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct OracleDialect; impl Dialect for OracleDialect { // ~ appears not to be called anywhere fn identifier_quote_style(&self, _identifier: &str) -> Option { Some('"') } fn is_delimited_identifier_start(&self, ch: char) -> bool { ch == '"' } fn is_identifier_start(&self, ch: char) -> bool { ch.is_alphabetic() } fn is_identifier_part(&self, ch: char) -> bool { ch.is_alphanumeric() || ch == '_' || ch == '$' || ch == '#' || ch == '@' } fn supports_outer_join_operator(&self) -> bool { true } fn supports_connect_by(&self) -> bool { true } fn supports_execute_immediate(&self) -> bool { true } fn supports_match_recognize(&self) -> bool { true } fn supports_window_function_null_treatment_arg(&self) -> bool { true } fn supports_boolean_literals(&self) -> bool { false } fn supports_comment_on(&self) -> bool { true } fn supports_create_table_select(&self) -> bool { true } fn supports_set_stmt_without_operator(&self) -> bool { true } fn get_next_precedence(&self, parser: &Parser) -> Option> { let t = parser.peek_token_ref(); debug!("get_next_precedence() {t:?}"); match &t.token { Token::StringConcat => Some(Ok(self.prec_value(Precedence::PlusMinus))), _ => None, } } fn supports_group_by_expr(&self) -> bool { true } fn get_reserved_keywords_for_select_item_operator(&self) -> &[Keyword] { &RESERVED_KEYWORDS_FOR_SELECT_ITEM_OPERATOR } fn supports_quote_delimited_string(&self) -> bool { true } fn supports_comment_optimizer_hint(&self) -> bool { true } fn supports_insert_table_alias(&self) -> bool { true } /// See fn supports_insert_table_query(&self) -> bool { true } } apache-datafusion-sqlparser-rs-0.62.0/src/dialect/postgresql.rs000066400000000000000000000235431517524037000245670ustar00rootroot00000000000000// 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. // Licensed 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 log::debug; use crate::dialect::{Dialect, Precedence}; use crate::keywords::Keyword; use crate::parser::{Parser, ParserError}; use crate::tokenizer::Token; use super::keywords::RESERVED_FOR_IDENTIFIER; /// A [`Dialect`] for [PostgreSQL](https://www.postgresql.org/) #[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct PostgreSqlDialect {} const PERIOD_PREC: u8 = 200; const DOUBLE_COLON_PREC: u8 = 140; const BRACKET_PREC: u8 = 130; const COLLATE_PREC: u8 = 120; const AT_TZ_PREC: u8 = 110; const CARET_PREC: u8 = 100; const MUL_DIV_MOD_OP_PREC: u8 = 90; const PLUS_MINUS_PREC: u8 = 80; // there's no XOR operator in PostgreSQL, but support it here to avoid breaking tests const XOR_PREC: u8 = 75; const PG_OTHER_PREC: u8 = 70; const BETWEEN_LIKE_PREC: u8 = 60; const EQ_PREC: u8 = 50; const IS_PREC: u8 = 40; const NOT_PREC: u8 = 30; const AND_PREC: u8 = 20; const OR_PREC: u8 = 10; impl Dialect for PostgreSqlDialect { fn identifier_quote_style(&self, _identifier: &str) -> Option { Some('"') } fn is_delimited_identifier_start(&self, ch: char) -> bool { ch == '"' // Postgres does not support backticks to quote identifiers } fn is_identifier_start(&self, ch: char) -> bool { ch.is_alphabetic() || ch == '_' || // PostgreSQL implements Unicode characters in identifiers. !ch.is_ascii() } fn is_identifier_part(&self, ch: char) -> bool { ch.is_alphabetic() || ch.is_ascii_digit() || ch == '$' || ch == '_' || // PostgreSQL implements Unicode characters in identifiers. !ch.is_ascii() } fn supports_unicode_string_literal(&self) -> bool { true } fn is_reserved_for_identifier(&self, kw: Keyword) -> bool { if matches!(kw, Keyword::INTERVAL) { false } else { RESERVED_FOR_IDENTIFIER.contains(&kw) } } /// See fn is_custom_operator_part(&self, ch: char) -> bool { matches!( ch, '+' | '-' | '*' | '/' | '<' | '>' | '=' | '~' | '!' | '@' | '#' | '%' | '^' | '&' | '|' | '`' | '?' ) } fn get_next_precedence(&self, parser: &Parser) -> Option> { let token = parser.peek_token_ref(); 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 match &token.token { Token::Word(w) if w.keyword == Keyword::COLLATE && !parser.in_column_definition_state() => { Some(Ok(COLLATE_PREC)) } Token::LBracket => Some(Ok(BRACKET_PREC)), Token::Arrow | Token::LongArrow | Token::HashArrow | Token::HashLongArrow | Token::AtArrow | Token::ArrowAt | Token::HashMinus | Token::AtQuestion | Token::AtAt | Token::Question | Token::QuestionAnd | Token::QuestionPipe | Token::ExclamationMark | Token::Overlap | Token::CaretAt | Token::StringConcat | Token::Sharp | Token::ShiftRight | Token::ShiftLeft | Token::CustomBinaryOperator(_) => Some(Ok(PG_OTHER_PREC)), // lowest prec to prevent it from turning into a binary op Token::Colon => Some(Ok(self.prec_unknown())), _ => None, } } fn supports_filter_during_aggregation(&self) -> bool { true } fn supports_group_by_expr(&self) -> bool { true } 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, Precedence::PlusMinus => PLUS_MINUS_PREC, Precedence::Xor => XOR_PREC, Precedence::Ampersand => PG_OTHER_PREC, Precedence::Caret => CARET_PREC, Precedence::Pipe => PG_OTHER_PREC, Precedence::Colon => PG_OTHER_PREC, Precedence::Between => BETWEEN_LIKE_PREC, Precedence::Eq => EQ_PREC, Precedence::Like => BETWEEN_LIKE_PREC, Precedence::Is => IS_PREC, Precedence::PgOther => PG_OTHER_PREC, Precedence::UnaryNot => NOT_PREC, Precedence::And => AND_PREC, Precedence::Or => OR_PREC, } } fn allow_extract_custom(&self) -> bool { true } fn allow_extract_single_quotes(&self) -> bool { true } fn supports_create_index_with_clause(&self) -> bool { true } /// see fn supports_explain_with_utility_options(&self) -> bool { true } /// see /// see /// see fn supports_listen_notify(&self) -> bool { true } /// see fn supports_factorial_operator(&self) -> bool { true } fn supports_bitwise_shift_operators(&self) -> bool { true } /// see fn supports_comment_on(&self) -> bool { true } /// See fn supports_load_extension(&self) -> bool { true } /// See /// /// Required to support the colon in: /// ```sql /// SELECT json_object('a': 'b') /// ``` fn supports_named_fn_args_with_colon_operator(&self) -> bool { true } /// See /// /// 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: fn supports_array_typedef_with_brackets(&self) -> bool { true } fn supports_geometric_types(&self) -> bool { true } fn supports_set_names(&self) -> bool { true } fn supports_alter_column_type_using(&self) -> bool { true } /// Postgres supports `NOTNULL` as an alias for `IS NOT NULL` /// See: fn supports_notnull_operator(&self) -> bool { true } /// [Postgres] supports optional field and precision options for `INTERVAL` data type. /// /// [Postgres]: https://www.postgresql.org/docs/17/datatype-datetime.html fn supports_interval_options(&self) -> bool { true } fn supports_insert_table_alias(&self) -> bool { true } fn supports_create_table_like_parenthesized(&self) -> bool { true } fn supports_select_wildcard_with_alias(&self) -> bool { true } fn supports_comma_separated_trim(&self) -> bool { true } fn supports_xml_expressions(&self) -> bool { true } /// Postgres supports query optimizer hints via the `pg_hint_plan` extension, /// using the same comment-prefixed-with-`+` syntax as MySQL and Oracle. /// /// See fn supports_comment_optimizer_hint(&self) -> bool { true } } apache-datafusion-sqlparser-rs-0.62.0/src/dialect/redshift.rs000066400000000000000000000124211517524037000241650ustar00rootroot00000000000000// 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 crate::dialect::Dialect; use core::iter::Peekable; use core::str::Chars; use super::PostgreSqlDialect; /// A [`Dialect`] for [RedShift](https://aws.amazon.com/redshift/) #[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct RedshiftSqlDialect {} // In most cases the redshift dialect is identical to [`PostgresSqlDialect`]. // // Notable differences: // 1. Redshift treats brackets `[` and `]` differently. For example, `SQL SELECT a[1][2] FROM b` // 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 == '[' } /// 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>, ) -> Option<(char, Option)> { if chars.peek() != Some(&'[') { return None; } 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)); } } None } fn is_identifier_start(&self, ch: char) -> bool { // UTF-8 multibyte characters are supported in identifiers via the PostgreSqlDialect. // https://docs.aws.amazon.com/redshift/latest/dg/r_names.html PostgreSqlDialect {}.is_identifier_start(ch) || ch == '#' } fn is_identifier_part(&self, ch: char) -> bool { // UTF-8 multibyte characters are supported in identifiers via the PostgreSqlDialect. // https://docs.aws.amazon.com/redshift/latest/dg/r_names.html PostgreSqlDialect {}.is_identifier_part(ch) || ch == '#' } /// redshift has `CONVERT(type, value)` instead of `CONVERT(value, type)` /// fn convert_type_before_value(&self) -> bool { true } fn supports_connect_by(&self) -> bool { true } /// Redshift expects the `TOP` option before the `ALL/DISTINCT` option: /// fn supports_top_before_distinct(&self) -> bool { true } /// Redshift supports PartiQL: fn supports_partiql(&self) -> bool { true } fn supports_string_escape_constant(&self) -> bool { true } fn supports_geometric_types(&self) -> bool { true } fn supports_bitwise_shift_operators(&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 } fn supports_select_wildcard_exclude(&self) -> bool { true } /// Redshift supports aliasing wildcard expressions: /// fn supports_select_wildcard_with_alias(&self) -> bool { true } fn supports_select_exclude(&self) -> bool { true } fn supports_create_table_like_parenthesized(&self) -> bool { true } fn supports_string_literal_concatenation_with_newline(&self) -> bool { true } fn supports_window_function_null_treatment_arg(&self) -> bool { true } } apache-datafusion-sqlparser-rs-0.62.0/src/dialect/snowflake.rs000066400000000000000000002136061517524037000243560ustar00rootroot00000000000000// 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. #[cfg(not(feature = "std"))] use crate::alloc::string::ToString; use crate::ast::helpers::attached_token::AttachedToken; use crate::ast::helpers::key_value_options::{ KeyValueOption, KeyValueOptionKind, KeyValueOptions, KeyValueOptionsDelimiter, }; use crate::ast::helpers::stmt_create_database::CreateDatabaseBuilder; use crate::ast::helpers::stmt_create_table::CreateTableBuilder; use crate::ast::helpers::stmt_data_loading::{ FileStagingCommand, StageLoadSelectItem, StageLoadSelectItemKind, StageParamsObject, }; use crate::ast::{ AlterTable, AlterTableOperation, AlterTableType, CatalogSyncNamespaceMode, ColumnOption, ColumnPolicy, ColumnPolicyProperty, ContactEntry, CopyIntoSnowflakeKind, CreateTable, CreateTableLikeKind, DollarQuotedString, Ident, IdentityParameters, IdentityProperty, IdentityPropertyFormatKind, IdentityPropertyKind, IdentityPropertyOrder, InitializeKind, Insert, MultiTableInsertIntoClause, MultiTableInsertType, MultiTableInsertValue, MultiTableInsertValues, MultiTableInsertWhenClause, ObjectName, ObjectNamePart, RefreshModeKind, RowAccessPolicy, ShowObjects, SqlOption, Statement, StorageLifecyclePolicy, StorageSerializationPolicy, TableObject, TagsColumnOption, Value, WrappedCollection, }; use crate::dialect::{Dialect, Precedence}; use crate::keywords::Keyword; use crate::parser::{IsOptional, Parser, ParserError}; use crate::tokenizer::TokenWithSpan; use crate::tokenizer::{Span, Token}; #[cfg(not(feature = "std"))] use alloc::boxed::Box; #[cfg(not(feature = "std"))] use alloc::string::String; #[cfg(not(feature = "std"))] use alloc::vec::Vec; #[cfg(not(feature = "std"))] use alloc::{format, vec}; use super::keywords::RESERVED_FOR_IDENTIFIER; const RESERVED_KEYWORDS_FOR_SELECT_ITEM_OPERATOR: [Keyword; 1] = [Keyword::CONNECT_BY_ROOT]; // See: const RESERVED_KEYWORDS_FOR_TABLE_FACTOR: &[Keyword] = &[ Keyword::ALL, Keyword::ALTER, Keyword::AND, Keyword::ANY, Keyword::AS, Keyword::BETWEEN, Keyword::BY, Keyword::CHECK, Keyword::COLUMN, Keyword::CONNECT, Keyword::CREATE, Keyword::CROSS, Keyword::CURRENT, Keyword::DELETE, Keyword::DISTINCT, Keyword::DROP, Keyword::ELSE, Keyword::EXISTS, Keyword::FOLLOWING, Keyword::FOR, Keyword::FROM, Keyword::FULL, Keyword::GRANT, Keyword::GROUP, Keyword::HAVING, Keyword::ILIKE, Keyword::IN, Keyword::INCREMENT, Keyword::INNER, Keyword::INSERT, Keyword::INTERSECT, Keyword::INTO, Keyword::IS, Keyword::JOIN, Keyword::LEFT, Keyword::LIKE, Keyword::MINUS, Keyword::NATURAL, Keyword::NOT, Keyword::NULL, Keyword::OF, Keyword::ON, Keyword::OR, Keyword::ORDER, Keyword::QUALIFY, Keyword::REGEXP, Keyword::REVOKE, Keyword::RIGHT, Keyword::RLIKE, Keyword::ROW, Keyword::ROWS, Keyword::SAMPLE, Keyword::SELECT, Keyword::SET, Keyword::SOME, Keyword::START, Keyword::TABLE, Keyword::TABLESAMPLE, Keyword::THEN, Keyword::TO, Keyword::TRIGGER, Keyword::UNION, Keyword::UNIQUE, Keyword::UPDATE, Keyword::USING, Keyword::VALUES, Keyword::WHEN, Keyword::WHENEVER, Keyword::WHERE, Keyword::WINDOW, Keyword::WITH, ]; /// A [`Dialect`] for [Snowflake](https://www.snowflake.com/) #[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct SnowflakeDialect; impl Dialect for SnowflakeDialect { // see https://docs.snowflake.com/en/sql-reference/identifiers-syntax.html fn is_identifier_start(&self, ch: char) -> bool { ch.is_ascii_lowercase() || ch.is_ascii_uppercase() || ch == '_' } fn supports_projection_trailing_commas(&self) -> bool { true } fn supports_from_trailing_commas(&self) -> bool { true } // Snowflake supports double-dot notation when the schema name is not specified // In this case the default PUBLIC schema is used // // see https://docs.snowflake.com/en/sql-reference/name-resolution#resolution-when-schema-omitted-double-dot-notation fn supports_object_name_double_dot_notation(&self) -> bool { true } fn is_identifier_part(&self, ch: char) -> bool { ch.is_ascii_lowercase() || ch.is_ascii_uppercase() || ch.is_ascii_digit() || ch == '$' || ch == '_' } // See https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#escape_sequences fn supports_string_literal_backslash_escape(&self) -> bool { true } fn supports_within_after_array_aggregation(&self) -> bool { true } /// See fn supports_outer_join_operator(&self) -> bool { true } fn supports_connect_by(&self) -> bool { true } /// See fn supports_execute_immediate(&self) -> bool { true } fn supports_match_recognize(&self) -> bool { true } // Snowflake uses this syntax for "object constants" (the values of which // are not actually required to be constants). // // https://docs.snowflake.com/en/sql-reference/data-types-semistructured#label-object-constant fn supports_dictionary_syntax(&self) -> bool { true } // Snowflake doesn't document this but `FIRST_VALUE(arg, { IGNORE | RESPECT } NULLS)` // works (i.e. inside the argument list instead of after). fn supports_window_function_null_treatment_arg(&self) -> bool { true } /// See [doc](https://docs.snowflake.com/en/sql-reference/sql/set#syntax) fn supports_parenthesized_set_variables(&self) -> bool { true } /// See [doc](https://docs.snowflake.com/en/sql-reference/sql/comment) fn supports_comment_on(&self) -> bool { true } /// See [doc](https://docs.snowflake.com/en/sql-reference/functions/extract) fn supports_extract_comma_syntax(&self) -> bool { true } /// See [doc](https://docs.snowflake.com/en/sql-reference/functions/flatten) fn supports_subquery_as_function_arg(&self) -> bool { true } /// See [doc](https://docs.snowflake.com/en/sql-reference/sql/create-view#optional-parameters) fn supports_create_view_comment_syntax(&self) -> bool { true } /// See [doc](https://docs.snowflake.com/en/sql-reference/data-types-semistructured#array) fn supports_array_typedef_without_element_type(&self) -> bool { true } /// See [doc](https://docs.snowflake.com/en/sql-reference/constructs/from) fn supports_parens_around_table_factor(&self) -> bool { true } /// See [doc](https://docs.snowflake.com/en/sql-reference/constructs/values) fn supports_values_as_table_factor(&self) -> bool { true } fn parse_statement(&self, parser: &mut Parser) -> Option> { if parser.parse_keyword(Keyword::BEGIN) { // Snowflake supports both `BEGIN TRANSACTION` and `BEGIN ... END` blocks. // If the next keyword indicates a transaction statement, let the // standard parse_begin() handle it. if parser .peek_one_of_keywords(&[Keyword::TRANSACTION, Keyword::WORK, Keyword::NAME]) .is_some() || matches!(parser.peek_token_ref().token, Token::SemiColon | Token::EOF) { parser.prev_token(); return None; } return Some(parser.parse_begin_exception_end()); } if parser.parse_keywords(&[Keyword::ALTER, Keyword::DYNAMIC, Keyword::TABLE]) { // ALTER DYNAMIC TABLE return Some(parse_alter_dynamic_table(parser)); } if parser.parse_keywords(&[Keyword::ALTER, Keyword::EXTERNAL, Keyword::TABLE]) { // ALTER EXTERNAL TABLE return Some(parse_alter_external_table(parser)); } if parser.parse_keywords(&[Keyword::ALTER, Keyword::SESSION]) { // ALTER SESSION let set = match parser.parse_one_of_keywords(&[Keyword::SET, Keyword::UNSET]) { Some(Keyword::SET) => true, Some(Keyword::UNSET) => false, _ => return Some(parser.expected_ref("SET or UNSET", parser.peek_token_ref())), }; return Some(parse_alter_session(parser, set)); } if parser.parse_keyword(Keyword::CREATE) { // possibly CREATE STAGE //[ OR REPLACE ] let or_replace = parser.parse_keywords(&[Keyword::OR, Keyword::REPLACE]); // LOCAL | GLOBAL let global = match parser.parse_one_of_keywords(&[Keyword::LOCAL, Keyword::GLOBAL]) { Some(Keyword::LOCAL) => Some(false), Some(Keyword::GLOBAL) => Some(true), _ => None, }; let dynamic = parser.parse_keyword(Keyword::DYNAMIC); let mut temporary = false; let mut volatile = false; let mut transient = false; let mut iceberg = false; match parser.parse_one_of_keywords(&[ Keyword::TEMP, Keyword::TEMPORARY, Keyword::VOLATILE, Keyword::TRANSIENT, Keyword::ICEBERG, ]) { Some(Keyword::TEMP | Keyword::TEMPORARY) => temporary = true, Some(Keyword::VOLATILE) => volatile = true, Some(Keyword::TRANSIENT) => transient = true, Some(Keyword::ICEBERG) => iceberg = true, _ => {} } if parser.parse_keyword(Keyword::STAGE) { // OK - this is CREATE STAGE statement return Some(parse_create_stage(or_replace, temporary, parser)); } else if parser.parse_keyword(Keyword::TABLE) { return Some( parse_create_table( or_replace, global, temporary, volatile, transient, iceberg, dynamic, parser, ) .map(Into::into), ); } else if parser.parse_keyword(Keyword::DATABASE) { return Some(parse_create_database(or_replace, transient, parser)); } else { // need to go back with the cursor let mut back = 1; if or_replace { back += 2 } if temporary { back += 1 } for _i in 0..back { parser.prev_token(); } } } if parser.parse_keywords(&[Keyword::COPY, Keyword::INTO]) { // COPY INTO return Some(parse_copy_into(parser)); } if let Some(kw) = parser.parse_one_of_keywords(&[ Keyword::LIST, Keyword::LS, Keyword::REMOVE, Keyword::RM, ]) { return Some(parse_file_staging_command(kw, parser)); } if parser.parse_keyword(Keyword::SHOW) { let terse = parser.parse_keyword(Keyword::TERSE); if parser.parse_keyword(Keyword::OBJECTS) { return Some(parse_show_objects(terse, parser)); } //Give back Keyword::TERSE if terse { parser.prev_token(); } //Give back Keyword::SHOW parser.prev_token(); } // Check for multi-table INSERT // `INSERT [OVERWRITE] ALL ... or INSERT [OVERWRITE] FIRST ...` if parser.parse_keyword(Keyword::INSERT) { let insert_token = parser.get_current_token().clone(); let overwrite = parser.parse_keyword(Keyword::OVERWRITE); // Check for ALL or FIRST keyword if let Some(kw) = parser.parse_one_of_keywords(&[Keyword::ALL, Keyword::FIRST]) { let multi_table_insert_type = match kw { Keyword::FIRST => MultiTableInsertType::First, _ => MultiTableInsertType::All, }; return Some(parse_multi_table_insert( parser, insert_token, overwrite, multi_table_insert_type, )); } // Not a multi-table insert, rewind if overwrite { parser.prev_token(); // rewind OVERWRITE } parser.prev_token(); // rewind INSERT } None } fn parse_column_option( &self, parser: &mut Parser, ) -> Result, ParserError>>, ParserError> { parser.maybe_parse(|parser| { let with = parser.parse_keyword(Keyword::WITH); if parser.parse_keyword(Keyword::IDENTITY) { Ok(parse_identity_property(parser) .map(|p| Some(ColumnOption::Identity(IdentityPropertyKind::Identity(p))))) } else if parser.parse_keyword(Keyword::AUTOINCREMENT) { Ok(parse_identity_property(parser).map(|p| { Some(ColumnOption::Identity(IdentityPropertyKind::Autoincrement( p, ))) })) } else if parser.parse_keywords(&[Keyword::MASKING, Keyword::POLICY]) { Ok(parse_column_policy_property(parser, with) .map(|p| Some(ColumnOption::Policy(ColumnPolicy::MaskingPolicy(p))))) } else if parser.parse_keywords(&[Keyword::PROJECTION, Keyword::POLICY]) { Ok(parse_column_policy_property(parser, with) .map(|p| Some(ColumnOption::Policy(ColumnPolicy::ProjectionPolicy(p))))) } else if parser.parse_keywords(&[Keyword::TAG]) { Ok(parse_column_tags(parser, with).map(|p| Some(ColumnOption::Tags(p)))) } else { Err(ParserError::ParserError("not found match".to_string())) } }) } fn get_next_precedence(&self, parser: &Parser) -> Option> { let token = parser.peek_token_ref(); // Snowflake supports the `:` cast operator unlike other dialects match &token.token { Token::Colon => Some(Ok(self.prec_value(Precedence::DoubleColon))), _ => None, } } fn describe_requires_table_keyword(&self) -> bool { true } fn allow_extract_custom(&self) -> bool { true } fn allow_extract_single_quotes(&self) -> bool { true } /// Snowflake expects the `LIKE` option before the `IN` option, /// for example: fn supports_show_like_before_in(&self) -> bool { true } fn supports_left_associative_joins_without_parens(&self) -> bool { false } fn is_reserved_for_identifier(&self, kw: Keyword) -> bool { // Unreserve some keywords that Snowflake accepts as identifiers // See: https://docs.snowflake.com/en/sql-reference/reserved-keywords if matches!(kw, Keyword::INTERVAL) { false } else { RESERVED_FOR_IDENTIFIER.contains(&kw) } } fn supports_partiql(&self) -> bool { true } fn is_column_alias(&self, kw: &Keyword, parser: &mut Parser) -> bool { match kw { // The following keywords can be considered an alias as long as // they are not followed by other tokens that may change their meaning // e.g. `SELECT * EXCEPT (col1) FROM tbl` Keyword::EXCEPT // e.g. `INSERT INTO t SELECT 1 RETURNING *` | Keyword::RETURNING if !matches!(parser.peek_token_ref().token, Token::Comma | Token::EOF) => { false } // e.g. `SELECT 1 LIMIT 5` - not an alias // e.g. `SELECT 1 OFFSET 5 ROWS` - not an alias Keyword::LIMIT | Keyword::OFFSET if peek_for_limit_options(parser) => false, // `FETCH` can be considered an alias as long as it's not followed by `FIRST`` or `NEXT` // which would give it a different meanings, for example: // `SELECT 1 FETCH FIRST 10 ROWS` - not an alias // `SELECT 1 FETCH 10` - not an alias Keyword::FETCH if parser.peek_one_of_keywords(&[Keyword::FIRST, Keyword::NEXT]).is_some() || peek_for_limit_options(parser) => { false } // Reserved keywords by the Snowflake dialect, which seem to be less strictive // than what is listed in `keywords::RESERVED_FOR_COLUMN_ALIAS`. The following // keywords were tested with the this statement: `SELECT 1 `. Keyword::FROM | Keyword::GROUP | Keyword::HAVING | Keyword::INTERSECT | Keyword::INTO | Keyword::MINUS | Keyword::ORDER | Keyword::SELECT | Keyword::UNION | Keyword::WHERE | Keyword::WITH => false, // Any other word is considered an alias _ => true, } } fn is_table_alias(&self, kw: &Keyword, parser: &mut Parser) -> bool { match kw { // The following keywords can be considered an alias as long as // they are not followed by other tokens that may change their meaning Keyword::RETURNING | Keyword::INNER | Keyword::USING | Keyword::PIVOT | Keyword::UNPIVOT | Keyword::EXCEPT | Keyword::MATCH_RECOGNIZE if !matches!(parser.peek_token_ref().token, Token::SemiColon | Token::EOF) => { false } // `LIMIT` can be considered an alias as long as it's not followed by a value. For example: // `SELECT * FROM tbl LIMIT WHERE 1=1` - alias // `SELECT * FROM tbl LIMIT 3` - not an alias Keyword::LIMIT | Keyword::OFFSET if peek_for_limit_options(parser) => false, // `FETCH` can be considered an alias as long as it's not followed by `FIRST`` or `NEXT` // which would give it a different meanings, for example: // `SELECT * FROM tbl FETCH FIRST 10 ROWS` - not an alias // `SELECT * FROM tbl FETCH 10` - not an alias Keyword::FETCH if parser .peek_one_of_keywords(&[Keyword::FIRST, Keyword::NEXT]) .is_some() || peek_for_limit_options(parser) => { false } // All sorts of join-related keywords can be considered aliases unless additional // keywords change their meaning. Keyword::RIGHT | Keyword::LEFT | Keyword::SEMI | Keyword::ANTI if parser .peek_one_of_keywords(&[Keyword::JOIN, Keyword::OUTER]) .is_some() => { false } Keyword::GLOBAL if parser.peek_keyword(Keyword::FULL) => false, // Reserved keywords by the Snowflake dialect, which seem to be less strictive // than what is listed in `keywords::RESERVED_FOR_TABLE_ALIAS`. The following // keywords were tested with the this statement: `SELECT .* FROM tbl `. Keyword::WITH | Keyword::ORDER | Keyword::SELECT | Keyword::WHERE | Keyword::GROUP | Keyword::HAVING | Keyword::LATERAL | Keyword::UNION | Keyword::INTERSECT | Keyword::MINUS | Keyword::ON | Keyword::JOIN | Keyword::INNER | Keyword::CROSS | Keyword::FULL | Keyword::LEFT | Keyword::RIGHT | Keyword::NATURAL | Keyword::USING | Keyword::ASOF | Keyword::MATCH_CONDITION | Keyword::SET | Keyword::QUALIFY | Keyword::FOR | Keyword::START | Keyword::CONNECT | Keyword::SAMPLE | Keyword::TABLESAMPLE | Keyword::FROM => false, // Any other word is considered an alias _ => true, } } fn is_table_factor(&self, kw: &Keyword, parser: &mut Parser) -> bool { match kw { Keyword::LIMIT if peek_for_limit_options(parser) => false, // Table function Keyword::TABLE if matches!(parser.peek_token_ref().token, Token::LParen) => true, _ => !RESERVED_KEYWORDS_FOR_TABLE_FACTOR.contains(kw), } } /// See: fn supports_table_versioning(&self) -> bool { true } /// See: fn supports_group_by_expr(&self) -> bool { true } /// See: fn get_reserved_keywords_for_select_item_operator(&self) -> &[Keyword] { &RESERVED_KEYWORDS_FOR_SELECT_ITEM_OPERATOR } fn supports_space_separated_column_options(&self) -> bool { true } fn supports_comma_separated_drop_column_list(&self) -> bool { true } fn is_identifier_generating_function_name( &self, ident: &Ident, name_parts: &[ObjectNamePart], ) -> bool { ident.quote_style.is_none() && ident.value.to_lowercase() == "identifier" && !name_parts .iter() .any(|p| matches!(p, ObjectNamePart::Function(_))) } // For example: `SELECT IDENTIFIER('alias1').* FROM tbl AS alias1` fn supports_select_expr_star(&self) -> bool { true } fn supports_select_wildcard_exclude(&self) -> bool { true } fn supports_semantic_view_table_factor(&self) -> bool { true } /// See fn supports_select_wildcard_replace(&self) -> bool { true } /// See fn supports_select_wildcard_ilike(&self) -> bool { true } /// See fn supports_select_wildcard_rename(&self) -> bool { true } /// See fn supports_lambda_functions(&self) -> bool { true } fn supports_comma_separated_trim(&self) -> bool { true } } // Peeks ahead to identify tokens that are expected after // a LIMIT/FETCH keyword. fn peek_for_limit_options(parser: &Parser) -> bool { match &parser.peek_token_ref().token { Token::Number(_, _) | Token::Placeholder(_) => true, Token::SingleQuotedString(val) if val.is_empty() => true, Token::DollarQuotedString(DollarQuotedString { value, .. }) if value.is_empty() => true, Token::Word(w) if w.keyword == Keyword::NULL => true, _ => false, } } fn parse_file_staging_command(kw: Keyword, parser: &mut Parser) -> Result { let stage = parse_snowflake_stage_name(parser)?; let pattern = if parser.parse_keyword(Keyword::PATTERN) { parser.expect_token(&Token::Eq)?; Some(parser.parse_literal_string()?) } else { None }; match kw { Keyword::LIST | Keyword::LS => Ok(Statement::List(FileStagingCommand { stage, pattern })), Keyword::REMOVE | Keyword::RM => { Ok(Statement::Remove(FileStagingCommand { stage, pattern })) } _ => Err(ParserError::ParserError( "unexpected stage command, expecting LIST, LS, REMOVE or RM".to_string(), )), } } /// Parse snowflake alter dynamic table. /// fn parse_alter_dynamic_table(parser: &mut Parser) -> Result { // Use parse_object_name(true) to support IDENTIFIER() function let table_name = parser.parse_object_name(true)?; // Parse the operation (REFRESH, SUSPEND, or RESUME) let operation = if parser.parse_keyword(Keyword::REFRESH) { AlterTableOperation::Refresh { subpath: None } } else if parser.parse_keyword(Keyword::SUSPEND) { AlterTableOperation::Suspend } else if parser.parse_keyword(Keyword::RESUME) { AlterTableOperation::Resume } else { return parser.expected_ref( "REFRESH, SUSPEND, or RESUME after ALTER DYNAMIC TABLE", parser.peek_token_ref(), ); }; let end_token = if parser.peek_token_ref().token == Token::SemiColon { parser.peek_token_ref().clone() } else { parser.get_current_token().clone() }; Ok(Statement::AlterTable(AlterTable { name: table_name, if_exists: false, only: false, operations: vec![operation], location: None, on_cluster: None, table_type: Some(AlterTableType::Dynamic), end_token: AttachedToken(end_token), })) } /// Parse snowflake alter external table. /// fn parse_alter_external_table(parser: &mut Parser) -> Result { let if_exists = parser.parse_keywords(&[Keyword::IF, Keyword::EXISTS]); let table_name = parser.parse_object_name(true)?; // Parse the operation (REFRESH for now) let operation = if parser.parse_keyword(Keyword::REFRESH) { // Optional subpath for refreshing specific partitions let subpath = match parser.peek_token().token { Token::SingleQuotedString(s) => { parser.next_token(); Some(s) } _ => None, }; AlterTableOperation::Refresh { subpath } } else { return parser.expected_ref( "REFRESH after ALTER EXTERNAL TABLE", parser.peek_token_ref(), ); }; let end_token = if parser.peek_token_ref().token == Token::SemiColon { parser.peek_token_ref().clone() } else { parser.get_current_token().clone() }; Ok(Statement::AlterTable(AlterTable { name: table_name, if_exists, only: false, operations: vec![operation], location: None, on_cluster: None, table_type: Some(AlterTableType::External), end_token: AttachedToken(end_token), })) } /// Parse snowflake alter session. /// fn parse_alter_session(parser: &mut Parser, set: bool) -> Result { let session_options = parse_session_options(parser, set)?; Ok(Statement::AlterSession { set, session_params: KeyValueOptions { options: session_options, delimiter: KeyValueOptionsDelimiter::Space, }, }) } /// Parse snowflake create table statement. /// /// #[allow(clippy::too_many_arguments)] pub fn parse_create_table( or_replace: bool, global: Option, temporary: bool, volatile: bool, transient: bool, iceberg: bool, dynamic: bool, parser: &mut Parser, ) -> Result { let if_not_exists = parser.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]); let table_name = parser.parse_object_name(false)?; let mut builder = CreateTableBuilder::new(table_name) .or_replace(or_replace) .if_not_exists(if_not_exists) .temporary(temporary) .transient(transient) .volatile(volatile) .iceberg(iceberg) .global(global) .dynamic(dynamic) .hive_formats(None); // Snowflake does not enforce order of the parameters in the statement. The parser needs to // parse the statement in a loop. // // "CREATE TABLE x COPY GRANTS (c INT)" and "CREATE TABLE x (c INT) COPY GRANTS" are both // accepted by Snowflake let mut plain_options = vec![]; loop { let next_token = parser.next_token(); match &next_token.token { Token::Word(word) => match word.keyword { Keyword::COPY => { parser.expect_keyword_is(Keyword::GRANTS)?; builder = builder.copy_grants(true); } Keyword::COMMENT => { // Rewind the COMMENT keyword parser.prev_token(); if let Some(comment_def) = parser.parse_optional_inline_comment()? { plain_options.push(SqlOption::Comment(comment_def)) } } Keyword::AS => { let query = parser.parse_query()?; builder = builder.query(Some(query)); } Keyword::CLONE => { let clone = parser.parse_object_name(false).ok(); builder = builder.clone_clause(clone); } Keyword::LIKE => { let name = parser.parse_object_name(false)?; builder = builder.like(Some(CreateTableLikeKind::Plain( crate::ast::CreateTableLike { name, defaults: None, }, ))); } Keyword::CLUSTER => { parser.expect_keyword_is(Keyword::BY)?; parser.expect_token(&Token::LParen)?; let cluster_by = Some(WrappedCollection::Parentheses( parser.parse_comma_separated(|p| p.parse_expr())?, )); parser.expect_token(&Token::RParen)?; builder = builder.cluster_by(cluster_by) } Keyword::ENABLE_SCHEMA_EVOLUTION => { parser.expect_token(&Token::Eq)?; builder = builder.enable_schema_evolution(Some(parser.parse_boolean_string()?)); } Keyword::CHANGE_TRACKING => { parser.expect_token(&Token::Eq)?; builder = builder.change_tracking(Some(parser.parse_boolean_string()?)); } Keyword::DATA_RETENTION_TIME_IN_DAYS => { parser.expect_token(&Token::Eq)?; let data_retention_time_in_days = parser.parse_literal_uint()?; builder = builder.data_retention_time_in_days(Some(data_retention_time_in_days)); } Keyword::MAX_DATA_EXTENSION_TIME_IN_DAYS => { parser.expect_token(&Token::Eq)?; let max_data_extension_time_in_days = parser.parse_literal_uint()?; builder = builder .max_data_extension_time_in_days(Some(max_data_extension_time_in_days)); } Keyword::DEFAULT_DDL_COLLATION => { parser.expect_token(&Token::Eq)?; let default_ddl_collation = parser.parse_literal_string()?; builder = builder.default_ddl_collation(Some(default_ddl_collation)); } // WITH is optional, we just verify that next token is one of the expected ones and // fallback to the default match statement Keyword::WITH => { parser.expect_one_of_keywords(&[ Keyword::AGGREGATION, Keyword::STORAGE, Keyword::TAG, Keyword::ROW, ])?; parser.prev_token(); } Keyword::AGGREGATION => { parser.expect_keyword_is(Keyword::POLICY)?; let aggregation_policy = parser.parse_object_name(false)?; builder = builder.with_aggregation_policy(Some(aggregation_policy)); } Keyword::ROW => { parser.expect_keywords(&[Keyword::ACCESS, Keyword::POLICY])?; let policy = parser.parse_object_name(false)?; parser.expect_keyword_is(Keyword::ON)?; parser.expect_token(&Token::LParen)?; let columns = parser.parse_comma_separated(|p| p.parse_identifier())?; parser.expect_token(&Token::RParen)?; builder = builder.with_row_access_policy(Some(RowAccessPolicy::new(policy, columns))) } Keyword::STORAGE => { parser.expect_keywords(&[Keyword::LIFECYCLE, Keyword::POLICY])?; let policy = parser.parse_object_name(false)?; parser.expect_keyword_is(Keyword::ON)?; parser.expect_token(&Token::LParen)?; let columns = parser.parse_comma_separated(|p| p.parse_identifier())?; parser.expect_token(&Token::RParen)?; builder = builder.with_storage_lifecycle_policy(Some(StorageLifecyclePolicy { policy, on: columns, })) } Keyword::TAG => { parser.expect_token(&Token::LParen)?; let tags = parser.parse_comma_separated(Parser::parse_tag)?; parser.expect_token(&Token::RParen)?; builder = builder.with_tags(Some(tags)); } Keyword::ON if parser.parse_keyword(Keyword::COMMIT) => { let on_commit = Some(parser.parse_create_table_on_commit()?); builder = builder.on_commit(on_commit); } Keyword::EXTERNAL_VOLUME => { parser.expect_token(&Token::Eq)?; builder.external_volume = Some(parser.parse_literal_string()?); } Keyword::CATALOG => { parser.expect_token(&Token::Eq)?; builder.catalog = Some(parser.parse_literal_string()?); } Keyword::BASE_LOCATION => { parser.expect_token(&Token::Eq)?; builder.base_location = Some(parser.parse_literal_string()?); } Keyword::CATALOG_SYNC => { parser.expect_token(&Token::Eq)?; builder.catalog_sync = Some(parser.parse_literal_string()?); } Keyword::STORAGE_SERIALIZATION_POLICY => { parser.expect_token(&Token::Eq)?; builder.storage_serialization_policy = Some(parse_storage_serialization_policy(parser)?); } Keyword::IF if parser.parse_keywords(&[Keyword::NOT, Keyword::EXISTS]) => { builder = builder.if_not_exists(true); } Keyword::TARGET_LAG => { parser.expect_token(&Token::Eq)?; let target_lag = parser.parse_literal_string()?; builder = builder.target_lag(Some(target_lag)); } Keyword::WAREHOUSE => { parser.expect_token(&Token::Eq)?; let warehouse = parser.parse_identifier()?; builder = builder.warehouse(Some(warehouse)); } Keyword::AT | Keyword::BEFORE => { parser.prev_token(); let version = parser.maybe_parse_table_version()?; builder = builder.version(version); } Keyword::REFRESH_MODE => { parser.expect_token(&Token::Eq)?; let refresh_mode = match parser.parse_one_of_keywords(&[ Keyword::AUTO, Keyword::FULL, Keyword::INCREMENTAL, ]) { Some(Keyword::AUTO) => Some(RefreshModeKind::Auto), Some(Keyword::FULL) => Some(RefreshModeKind::Full), Some(Keyword::INCREMENTAL) => Some(RefreshModeKind::Incremental), _ => return parser.expected("AUTO, FULL or INCREMENTAL", next_token), }; builder = builder.refresh_mode(refresh_mode); } Keyword::INITIALIZE => { parser.expect_token(&Token::Eq)?; let initialize = match parser .parse_one_of_keywords(&[Keyword::ON_CREATE, Keyword::ON_SCHEDULE]) { Some(Keyword::ON_CREATE) => Some(InitializeKind::OnCreate), Some(Keyword::ON_SCHEDULE) => Some(InitializeKind::OnSchedule), _ => return parser.expected("ON_CREATE or ON_SCHEDULE", next_token), }; builder = builder.initialize(initialize); } Keyword::REQUIRE if parser.parse_keyword(Keyword::USER) => { builder = builder.require_user(true); } _ => { return parser.expected("end of statement", next_token); } }, Token::LParen => { parser.prev_token(); let (columns, constraints) = parser.parse_columns()?; builder = builder.columns(columns).constraints(constraints); } Token::EOF => { break; } Token::SemiColon => { parser.prev_token(); break; } _ => { return parser.expected("end of statement", next_token); } } } let table_options = if !plain_options.is_empty() { crate::ast::CreateTableOptions::Plain(plain_options) } else { crate::ast::CreateTableOptions::None }; builder = builder.table_options(table_options); if iceberg && builder.base_location.is_none() { return Err(ParserError::ParserError( "BASE_LOCATION is required for ICEBERG tables".to_string(), )); } Ok(builder.build()) } /// Parse snowflake create database statement. /// pub fn parse_create_database( or_replace: bool, transient: bool, parser: &mut Parser, ) -> Result { let if_not_exists = parser.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]); let name = parser.parse_object_name(false)?; let mut builder = CreateDatabaseBuilder::new(name) .or_replace(or_replace) .transient(transient) .if_not_exists(if_not_exists); loop { let next_token = parser.next_token(); match &next_token.token { Token::Word(word) => match word.keyword { Keyword::CLONE => { builder = builder.clone_clause(Some(parser.parse_object_name(false)?)); } Keyword::DATA_RETENTION_TIME_IN_DAYS => { parser.expect_token(&Token::Eq)?; builder = builder.data_retention_time_in_days(Some(parser.parse_literal_uint()?)); } Keyword::MAX_DATA_EXTENSION_TIME_IN_DAYS => { parser.expect_token(&Token::Eq)?; builder = builder.max_data_extension_time_in_days(Some(parser.parse_literal_uint()?)); } Keyword::EXTERNAL_VOLUME => { parser.expect_token(&Token::Eq)?; builder = builder.external_volume(Some(parser.parse_literal_string()?)); } Keyword::CATALOG => { parser.expect_token(&Token::Eq)?; builder = builder.catalog(Some(parser.parse_literal_string()?)); } Keyword::REPLACE_INVALID_CHARACTERS => { parser.expect_token(&Token::Eq)?; builder = builder.replace_invalid_characters(Some(parser.parse_boolean_string()?)); } Keyword::DEFAULT_DDL_COLLATION => { parser.expect_token(&Token::Eq)?; builder = builder.default_ddl_collation(Some(parser.parse_literal_string()?)); } Keyword::STORAGE_SERIALIZATION_POLICY => { parser.expect_token(&Token::Eq)?; let policy = parse_storage_serialization_policy(parser)?; builder = builder.storage_serialization_policy(Some(policy)); } Keyword::COMMENT => { parser.expect_token(&Token::Eq)?; builder = builder.comment(Some(parser.parse_literal_string()?)); } Keyword::CATALOG_SYNC => { parser.expect_token(&Token::Eq)?; builder = builder.catalog_sync(Some(parser.parse_literal_string()?)); } Keyword::CATALOG_SYNC_NAMESPACE_FLATTEN_DELIMITER => { parser.expect_token(&Token::Eq)?; builder = builder.catalog_sync_namespace_flatten_delimiter(Some( parser.parse_literal_string()?, )); } Keyword::CATALOG_SYNC_NAMESPACE_MODE => { parser.expect_token(&Token::Eq)?; let mode = match parser.parse_one_of_keywords(&[Keyword::NEST, Keyword::FLATTEN]) { Some(Keyword::NEST) => CatalogSyncNamespaceMode::Nest, Some(Keyword::FLATTEN) => CatalogSyncNamespaceMode::Flatten, _ => { return parser.expected("NEST or FLATTEN", next_token); } }; builder = builder.catalog_sync_namespace_mode(Some(mode)); } Keyword::WITH => { if parser.parse_keyword(Keyword::TAG) { parser.expect_token(&Token::LParen)?; let tags = parser.parse_comma_separated(Parser::parse_tag)?; parser.expect_token(&Token::RParen)?; builder = builder.with_tags(Some(tags)); } else if parser.parse_keyword(Keyword::CONTACT) { parser.expect_token(&Token::LParen)?; let contacts = parser.parse_comma_separated(|p| { let purpose = p.parse_identifier()?.value; p.expect_token(&Token::Eq)?; let contact = p.parse_identifier()?.value; Ok(ContactEntry { purpose, contact }) })?; parser.expect_token(&Token::RParen)?; builder = builder.with_contacts(Some(contacts)); } else { return parser.expected("TAG or CONTACT", next_token); } } _ => return parser.expected("end of statement", next_token), }, Token::SemiColon | Token::EOF => break, _ => return parser.expected("end of statement", next_token), } } Ok(builder.build()) } pub fn parse_storage_serialization_policy( parser: &mut Parser, ) -> Result { let next_token = parser.next_token(); match &next_token.token { Token::Word(w) => match w.keyword { Keyword::COMPATIBLE => Ok(StorageSerializationPolicy::Compatible), Keyword::OPTIMIZED => Ok(StorageSerializationPolicy::Optimized), _ => parser.expected("storage_serialization_policy", next_token), }, _ => parser.expected("storage_serialization_policy", next_token), } } pub fn parse_create_stage( or_replace: bool, temporary: bool, parser: &mut Parser, ) -> Result { //[ IF NOT EXISTS ] let if_not_exists = parser.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]); let name = parser.parse_object_name(false)?; let mut directory_table_params = Vec::new(); let mut file_format = Vec::new(); let mut copy_options = Vec::new(); let mut comment = None; // [ internalStageParams | externalStageParams ] let stage_params = parse_stage_params(parser)?; // [ directoryTableParams ] if parser.parse_keyword(Keyword::DIRECTORY) { parser.expect_token(&Token::Eq)?; directory_table_params = parser.parse_key_value_options(true, &[])?.options; } // [ file_format] if parser.parse_keyword(Keyword::FILE_FORMAT) { parser.expect_token(&Token::Eq)?; file_format = parser.parse_key_value_options(true, &[])?.options; } // [ copy_options ] if parser.parse_keyword(Keyword::COPY_OPTIONS) { parser.expect_token(&Token::Eq)?; copy_options = parser.parse_key_value_options(true, &[])?.options; } // [ comment ] if parser.parse_keyword(Keyword::COMMENT) { parser.expect_token(&Token::Eq)?; comment = Some(parser.parse_comment_value()?); } Ok(Statement::CreateStage { or_replace, temporary, if_not_exists, name, stage_params, directory_table_params: KeyValueOptions { options: directory_table_params, delimiter: KeyValueOptionsDelimiter::Space, }, file_format: KeyValueOptions { options: file_format, delimiter: KeyValueOptionsDelimiter::Space, }, copy_options: KeyValueOptions { options: copy_options, delimiter: KeyValueOptionsDelimiter::Space, }, comment, }) } pub fn parse_stage_name_identifier(parser: &mut Parser) -> Result { let mut ident = String::new(); while let Some(next_token) = parser.next_token_no_skip() { match &next_token.token { Token::Whitespace(_) | Token::SemiColon => break, Token::Period => { parser.prev_token(); break; } Token::LParen | Token::RParen => { parser.prev_token(); break; } Token::AtSign => ident.push('@'), Token::Tilde => ident.push('~'), Token::Mod => ident.push('%'), Token::Div => ident.push('/'), Token::Plus => ident.push('+'), Token::Minus => ident.push('-'), Token::Eq => ident.push('='), Token::Colon => ident.push(':'), Token::Number(n, _) => ident.push_str(n), Token::Word(w) => ident.push_str(&w.to_string()), _ => return parser.expected_ref("stage name identifier", parser.peek_token_ref()), } } Ok(Ident::new(ident)) } /// Parses a Snowflake stage name, which may start with `@` for internal stages. /// Examples: `@mystage`, `@namespace.stage`, `schema.table` pub fn parse_snowflake_stage_name(parser: &mut Parser) -> Result { match parser.next_token().token { Token::AtSign => { parser.prev_token(); let mut idents = vec![]; loop { idents.push(parse_stage_name_identifier(parser)?); if !parser.consume_token(&Token::Period) { break; } } Ok(ObjectName::from(idents)) } _ => { parser.prev_token(); Ok(parser.parse_object_name(false)?) } } } /// Parses a `COPY INTO` statement. Snowflake has two variants, `COPY INTO
` /// and `COPY INTO ` which have different syntax. pub fn parse_copy_into(parser: &mut Parser) -> Result { let kind = match &parser.peek_token_ref().token { // Indicates an internal stage Token::AtSign => CopyIntoSnowflakeKind::Location, // Indicates an external stage, i.e. s3://, gcs:// or azure:// Token::SingleQuotedString(s) if s.contains("://") => CopyIntoSnowflakeKind::Location, _ => CopyIntoSnowflakeKind::Table, }; let mut files: Vec = vec![]; let mut from_transformations: Option> = None; let mut from_stage_alias = None; let mut from_stage = None; let mut stage_params = StageParamsObject { url: None, encryption: KeyValueOptions { options: vec![], delimiter: KeyValueOptionsDelimiter::Space, }, endpoint: None, storage_integration: None, credentials: KeyValueOptions { options: vec![], delimiter: KeyValueOptionsDelimiter::Space, }, }; let mut from_query = None; let mut partition = None; let mut file_format = Vec::new(); let mut pattern = None; let mut validation_mode = None; let mut copy_options = Vec::new(); let into: ObjectName = parse_snowflake_stage_name(parser)?; if kind == CopyIntoSnowflakeKind::Location { stage_params = parse_stage_params(parser)?; } let into_columns = match &parser.peek_token().token { Token::LParen => Some(parser.parse_parenthesized_column_list(IsOptional::Optional, true)?), _ => None, }; parser.expect_keyword_is(Keyword::FROM)?; match parser.next_token().token { Token::LParen if kind == CopyIntoSnowflakeKind::Table => { // Data load with transformations parser.expect_keyword_is(Keyword::SELECT)?; from_transformations = parse_select_items_for_data_load(parser)?; parser.expect_keyword_is(Keyword::FROM)?; from_stage = Some(parse_snowflake_stage_name(parser)?); stage_params = parse_stage_params(parser)?; // Parse an optional alias from_stage_alias = parser .maybe_parse_table_alias()? .map(|table_alias| table_alias.name); parser.expect_token(&Token::RParen)?; } Token::LParen if kind == CopyIntoSnowflakeKind::Location => { // Data unload with a query from_query = Some(parser.parse_query()?); parser.expect_token(&Token::RParen)?; } _ => { parser.prev_token(); from_stage = Some(parse_snowflake_stage_name(parser)?); stage_params = parse_stage_params(parser)?; // as from_stage_alias = if parser.parse_keyword(Keyword::AS) { Some(match parser.next_token().token { Token::Word(w) => Ok(Ident::new(w.value)), _ => parser.expected_ref("stage alias", parser.peek_token_ref()), }?) } else { None }; } } loop { // FILE_FORMAT if parser.parse_keyword(Keyword::FILE_FORMAT) { parser.expect_token(&Token::Eq)?; file_format = parser.parse_key_value_options(true, &[])?.options; // PARTITION BY } else if parser.parse_keywords(&[Keyword::PARTITION, Keyword::BY]) { partition = Some(Box::new(parser.parse_expr()?)) // FILES } else if parser.parse_keyword(Keyword::FILES) { parser.expect_token(&Token::Eq)?; parser.expect_token(&Token::LParen)?; let mut continue_loop = true; while continue_loop { continue_loop = false; let next_token = parser.next_token(); match next_token.token { Token::SingleQuotedString(s) => files.push(s), _ => parser.expected("file token", next_token)?, }; if parser.next_token().token.eq(&Token::Comma) { continue_loop = true; } else { parser.prev_token(); // not a comma, need to go back } } parser.expect_token(&Token::RParen)?; // PATTERN } else if parser.parse_keyword(Keyword::PATTERN) { parser.expect_token(&Token::Eq)?; let next_token = parser.next_token(); pattern = Some(match next_token.token { Token::SingleQuotedString(s) => s, _ => parser.expected("pattern", next_token)?, }); // VALIDATION MODE } else if parser.parse_keyword(Keyword::VALIDATION_MODE) { parser.expect_token(&Token::Eq)?; validation_mode = Some(parser.next_token().token.to_string()); // COPY OPTIONS } else if parser.parse_keyword(Keyword::COPY_OPTIONS) { parser.expect_token(&Token::Eq)?; copy_options = parser.parse_key_value_options(true, &[])?.options; } else { match parser.next_token().token { Token::SemiColon | Token::EOF => break, Token::Comma => continue, // In `COPY INTO ` the copy options do not have a shared key // like in `COPY INTO
` Token::Word(key) => copy_options.push(parser.parse_key_value_option(&key)?), _ => { return parser .expected_ref("another copy option, ; or EOF'", parser.peek_token_ref()) } } } } Ok(Statement::CopyIntoSnowflake { kind, into, into_columns, from_obj: from_stage, from_obj_alias: from_stage_alias, stage_params, from_transformations, from_query, files: if files.is_empty() { None } else { Some(files) }, pattern, file_format: KeyValueOptions { options: file_format, delimiter: KeyValueOptionsDelimiter::Space, }, copy_options: KeyValueOptions { options: copy_options, delimiter: KeyValueOptionsDelimiter::Space, }, validation_mode, partition, }) } fn parse_select_items_for_data_load( parser: &mut Parser, ) -> Result>, ParserError> { let mut select_items: Vec = vec![]; loop { match parser.maybe_parse(parse_select_item_for_data_load)? { // [.]$[.] [ , [.]$[.] ... ] Some(item) => select_items.push(StageLoadSelectItemKind::StageLoadSelectItem(item)), // Fallback, try to parse a standard SQL select item None => select_items.push(StageLoadSelectItemKind::SelectItem( parser.parse_select_item()?, )), } if matches!(parser.peek_token_ref().token, Token::Comma) { parser.advance_token(); } else { break; } } Ok(Some(select_items)) } fn parse_select_item_for_data_load( parser: &mut Parser, ) -> Result { let mut alias: Option = None; let mut file_col_num: i32 = 0; let mut element: Option = None; let mut item_as: Option = None; let next_token = parser.next_token(); match next_token.token { Token::Placeholder(w) => { file_col_num = w.to_string().split_off(1).parse::().map_err(|e| { ParserError::ParserError(format!("Could not parse '{w}' as i32: {e}")) })?; Ok(()) } Token::Word(w) => { alias = Some(Ident::new(w.value)); Ok(()) } _ => parser.expected("alias or file_col_num", next_token), }?; if alias.is_some() { parser.expect_token(&Token::Period)?; // now we get col_num token let col_num_token = parser.next_token(); match col_num_token.token { Token::Placeholder(w) => { file_col_num = w.to_string().split_off(1).parse::().map_err(|e| { ParserError::ParserError(format!("Could not parse '{w}' as i32: {e}")) })?; Ok(()) } _ => parser.expected("file_col_num", col_num_token), }?; } // try extracting optional element match parser.next_token().token { Token::Colon => { // parse element element = Some(Ident::new(match parser.next_token().token { Token::Word(w) => Ok(w.value), _ => parser.expected_ref("file_col_num", parser.peek_token_ref()), }?)); } _ => { // element not present move back parser.prev_token(); } } // as if parser.parse_keyword(Keyword::AS) { item_as = Some(match parser.next_token().token { Token::Word(w) => Ok(Ident::new(w.value)), _ => parser.expected_ref("column item alias", parser.peek_token_ref()), }?); } Ok(StageLoadSelectItem { alias, file_col_num, element, item_as, }) } fn parse_stage_params(parser: &mut Parser) -> Result { let (mut url, mut storage_integration, mut endpoint) = (None, None, None); let mut encryption: KeyValueOptions = KeyValueOptions { options: vec![], delimiter: KeyValueOptionsDelimiter::Space, }; let mut credentials: KeyValueOptions = KeyValueOptions { options: vec![], delimiter: KeyValueOptionsDelimiter::Space, }; // URL if parser.parse_keyword(Keyword::URL) { parser.expect_token(&Token::Eq)?; url = Some(match parser.next_token().token { Token::SingleQuotedString(word) => Ok(word), _ => parser.expected_ref("a URL statement", parser.peek_token_ref()), }?) } // STORAGE INTEGRATION if parser.parse_keyword(Keyword::STORAGE_INTEGRATION) { parser.expect_token(&Token::Eq)?; storage_integration = Some(parser.next_token().token.to_string()); } // ENDPOINT if parser.parse_keyword(Keyword::ENDPOINT) { parser.expect_token(&Token::Eq)?; endpoint = Some(match parser.next_token().token { Token::SingleQuotedString(word) => Ok(word), _ => parser.expected_ref("an endpoint statement", parser.peek_token_ref()), }?) } // CREDENTIALS if parser.parse_keyword(Keyword::CREDENTIALS) { parser.expect_token(&Token::Eq)?; credentials = KeyValueOptions { options: parser.parse_key_value_options(true, &[])?.options, delimiter: KeyValueOptionsDelimiter::Space, }; } // ENCRYPTION if parser.parse_keyword(Keyword::ENCRYPTION) { parser.expect_token(&Token::Eq)?; encryption = KeyValueOptions { options: parser.parse_key_value_options(true, &[])?.options, delimiter: KeyValueOptionsDelimiter::Space, }; } Ok(StageParamsObject { url, encryption, endpoint, storage_integration, credentials, }) } /// Parses options separated by blank spaces, commas, or new lines like: /// ABORT_DETACHED_QUERY = { TRUE | FALSE } /// [ ACTIVE_PYTHON_PROFILER = { 'LINE' | 'MEMORY' } ] /// [ BINARY_INPUT_FORMAT = '\' ] fn parse_session_options( parser: &mut Parser, set: bool, ) -> Result, ParserError> { let mut options: Vec = Vec::new(); let empty = String::new; loop { let peeked_token = parser.peek_token(); match peeked_token.token { Token::SemiColon | Token::EOF => break, Token::Comma => { parser.advance_token(); continue; } Token::Word(key) => { parser.advance_token(); if set { let option = parser.parse_key_value_option(&key)?; options.push(option); } else { options.push(KeyValueOption { option_name: key.value, option_value: KeyValueOptionKind::Single( Value::Placeholder(empty()).with_span(Span { start: peeked_token.span.end, end: peeked_token.span.end, }), ), }); } } _ => { return parser.expected("another option or end of statement", peeked_token); } } } if options.is_empty() { Err(ParserError::ParserError( "expected at least one option".to_string(), )) } else { Ok(options) } } /// Parsing a property of identity or autoincrement column option /// Syntax: /// ```sql /// [ (seed , increment) | START num INCREMENT num ] [ ORDER | NOORDER ] /// ``` /// [Snowflake]: https://docs.snowflake.com/en/sql-reference/sql/create-table fn parse_identity_property(parser: &mut Parser) -> Result { let parameters = if parser.consume_token(&Token::LParen) { let seed = parser.parse_number()?; parser.expect_token(&Token::Comma)?; let increment = parser.parse_number()?; parser.expect_token(&Token::RParen)?; Some(IdentityPropertyFormatKind::FunctionCall( IdentityParameters { seed, increment }, )) } else if parser.parse_keyword(Keyword::START) { let seed = parser.parse_number()?; parser.expect_keyword_is(Keyword::INCREMENT)?; let increment = parser.parse_number()?; Some(IdentityPropertyFormatKind::StartAndIncrement( IdentityParameters { seed, increment }, )) } else { None }; let order = match parser.parse_one_of_keywords(&[Keyword::ORDER, Keyword::NOORDER]) { Some(Keyword::ORDER) => Some(IdentityPropertyOrder::Order), Some(Keyword::NOORDER) => Some(IdentityPropertyOrder::NoOrder), _ => None, }; Ok(IdentityProperty { parameters, order }) } /// Parsing a policy property of column option /// Syntax: /// ```sql /// [ USING ( , , ... ) /// ``` /// [Snowflake]: https://docs.snowflake.com/en/sql-reference/sql/create-table fn parse_column_policy_property( parser: &mut Parser, with: bool, ) -> Result { let policy_name = parser.parse_object_name(false)?; let using_columns = if parser.parse_keyword(Keyword::USING) { parser.expect_token(&Token::LParen)?; let columns = parser.parse_comma_separated(|p| p.parse_identifier())?; parser.expect_token(&Token::RParen)?; Some(columns) } else { None }; Ok(ColumnPolicyProperty { with, policy_name, using_columns, }) } /// Parsing tags list of column /// Syntax: /// ```sql /// ( = '' [ , = '' , ... ] ) /// ``` /// [Snowflake]: https://docs.snowflake.com/en/sql-reference/sql/create-table fn parse_column_tags(parser: &mut Parser, with: bool) -> Result { parser.expect_token(&Token::LParen)?; let tags = parser.parse_comma_separated(Parser::parse_tag)?; parser.expect_token(&Token::RParen)?; Ok(TagsColumnOption { with, tags }) } /// Parse snowflake show objects. /// fn parse_show_objects(terse: bool, parser: &mut Parser) -> Result { let show_options = parser.parse_show_stmt_options()?; Ok(Statement::ShowObjects(ShowObjects { terse, show_options, })) } /// Parse multi-table INSERT statement. /// /// Syntax: /// ```sql /// -- Unconditional multi-table insert /// INSERT [ OVERWRITE ] ALL /// intoClause [ ... ] /// /// /// -- Conditional multi-table insert /// INSERT [ OVERWRITE ] { FIRST | ALL } /// { WHEN THEN intoClause [ ... ] } /// [ ... ] /// [ ELSE intoClause ] /// /// ``` /// /// See: fn parse_multi_table_insert( parser: &mut Parser, insert_token: TokenWithSpan, overwrite: bool, multi_table_insert_type: MultiTableInsertType, ) -> Result { // Check if this is conditional (has WHEN clauses) or unconditional (direct INTO clauses) let is_conditional = parser.peek_keyword(Keyword::WHEN); let (multi_table_into_clauses, multi_table_when_clauses, multi_table_else_clause) = if is_conditional { // Conditional multi-table insert: WHEN clauses let (when_clauses, else_clause) = parse_multi_table_insert_when_clauses(parser)?; (vec![], when_clauses, else_clause) } else { // Unconditional multi-table insert: direct INTO clauses let into_clauses = parse_multi_table_insert_into_clauses(parser)?; (into_clauses, vec![], None) }; // Parse the source query let source = parser.parse_query()?; Ok(Statement::Insert(Insert { insert_token: insert_token.into(), optimizer_hints: vec![], or: None, ignore: false, into: false, table: TableObject::TableName(ObjectName(vec![])), // Not used for multi-table insert table_alias: None, columns: vec![], overwrite, source: Some(source), assignments: vec![], partitioned: None, after_columns: vec![], has_table_keyword: false, on: None, returning: None, output: None, replace_into: false, priority: None, insert_alias: None, settings: None, format_clause: None, multi_table_insert_type: Some(multi_table_insert_type), multi_table_into_clauses, multi_table_when_clauses, multi_table_else_clause, })) } /// Parse one or more INTO clauses for multi-table INSERT. fn parse_multi_table_insert_into_clauses( parser: &mut Parser, ) -> Result, ParserError> { let mut into_clauses = vec![]; while parser.parse_keyword(Keyword::INTO) { into_clauses.push(parse_multi_table_insert_into_clause(parser)?); } if into_clauses.is_empty() { return parser.expected_ref("INTO clause in multi-table INSERT", parser.peek_token_ref()); } Ok(into_clauses) } /// Parse a single INTO clause for multi-table INSERT. /// /// Syntax: `INTO
[ ( ) ] [ VALUES ( ) ]` fn parse_multi_table_insert_into_clause( parser: &mut Parser, ) -> Result { let table_name = parser.parse_object_name(false)?; // Parse optional column list: ( [, ...] ) let columns = parser .maybe_parse(|p| p.parse_parenthesized_column_list(IsOptional::Mandatory, false))? .unwrap_or_default(); // Parse optional VALUES clause let values = if parser.parse_keyword(Keyword::VALUES) { parser.expect_token(&Token::LParen)?; let values = parser.parse_comma_separated(parse_multi_table_insert_value)?; parser.expect_token(&Token::RParen)?; Some(MultiTableInsertValues { values }) } else { None }; Ok(MultiTableInsertIntoClause { table_name, columns, values, }) } /// Parse a single value in a multi-table INSERT VALUES clause. fn parse_multi_table_insert_value( parser: &mut Parser, ) -> Result { if parser.parse_keyword(Keyword::DEFAULT) { Ok(MultiTableInsertValue::Default) } else { Ok(MultiTableInsertValue::Expr(parser.parse_expr()?)) } } /// Parse WHEN clauses for conditional multi-table INSERT. fn parse_multi_table_insert_when_clauses( parser: &mut Parser, ) -> Result< ( Vec, Option>, ), ParserError, > { let mut when_clauses = vec![]; let mut else_clause = None; // Parse WHEN clauses while parser.parse_keyword(Keyword::WHEN) { let condition = parser.parse_expr()?; parser.expect_keyword(Keyword::THEN)?; // Parse INTO clauses for this WHEN let into_clauses = parse_multi_table_insert_into_clauses(parser)?; when_clauses.push(MultiTableInsertWhenClause { condition, into_clauses, }); } // Parse optional ELSE clause if parser.parse_keyword(Keyword::ELSE) { else_clause = Some(parse_multi_table_insert_into_clauses(parser)?); } if when_clauses.is_empty() { return parser.expected_ref( "at least one WHEN clause in conditional multi-table INSERT", parser.peek_token_ref(), ); } Ok((when_clauses, else_clause)) } apache-datafusion-sqlparser-rs-0.62.0/src/dialect/spark.rs000066400000000000000000000110071517524037000234740ustar00rootroot00000000000000// 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. #[cfg(not(feature = "std"))] use alloc::boxed::Box; use crate::ast::{BinaryOperator, Expr}; use crate::dialect::Dialect; use crate::keywords::Keyword; use crate::parser::{Parser, ParserError}; /// A [`Dialect`] for [Apache Spark SQL](https://spark.apache.org/docs/latest/sql-ref.html). /// /// See . #[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct SparkSqlDialect; impl Dialect for SparkSqlDialect { // See https://spark.apache.org/docs/latest/sql-ref-identifier.html fn is_delimited_identifier_start(&self, ch: char) -> bool { matches!(ch, '`') } fn is_identifier_start(&self, ch: char) -> bool { matches!(ch, 'a'..='z' | 'A'..='Z' | '_') } fn is_identifier_part(&self, ch: char) -> bool { matches!(ch, 'a'..='z' | 'A'..='Z' | '0'..='9' | '_') } /// See fn supports_filter_during_aggregation(&self) -> bool { true } /// See fn supports_group_by_expr(&self) -> bool { true } /// See fn supports_group_by_with_modifier(&self) -> bool { true } /// See fn supports_lambda_functions(&self) -> bool { true } /// See fn supports_select_wildcard_except(&self) -> bool { true } /// See fn supports_struct_literal(&self) -> bool { true } fn supports_nested_comments(&self) -> bool { true } /// See fn supports_create_table_using(&self) -> bool { true } /// `LONG` is an alias for `BIGINT` in Spark SQL. /// /// See fn supports_long_type_as_bigint(&self) -> bool { true } /// See fn supports_values_as_table_factor(&self) -> bool { true } fn require_interval_qualifier(&self) -> bool { true } fn supports_bang_not_operator(&self) -> bool { true } fn supports_select_item_multi_column_alias(&self) -> bool { true } fn supports_cte_without_as(&self) -> bool { true } /// See fn supports_map_literal_with_angle_brackets(&self) -> bool { true } /// Parse the `DIV` keyword as integer division. /// /// Example: `SELECT 10 DIV 3` returns `3`. /// /// See fn parse_infix( &self, parser: &mut Parser, expr: &Expr, _precedence: u8, ) -> Option> { if parser.parse_keyword(Keyword::DIV) { let left = Box::new(expr.clone()); let right = Box::new(match parser.parse_expr() { Ok(expr) => expr, Err(e) => return Some(Err(e)), }); Some(Ok(Expr::BinaryOp { left, op: BinaryOperator::MyIntegerDivide, right, })) } else { None } } } apache-datafusion-sqlparser-rs-0.62.0/src/dialect/sqlite.rs000066400000000000000000000102271517524037000236600ustar00rootroot00000000000000// 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. #[cfg(not(feature = "std"))] use alloc::boxed::Box; use crate::ast::BinaryOperator; use crate::ast::{Expr, Statement}; use crate::dialect::Dialect; use crate::keywords::Keyword; use crate::parser::{Parser, ParserError}; /// A [`Dialect`] for [SQLite](https://www.sqlite.org) /// /// This dialect allows columns in a /// [`CREATE TABLE`](https://sqlite.org/lang_createtable.html) statement with no /// type specified, as in `CREATE TABLE t1 (a)`. In the AST, these columns will /// have the data type [`Unspecified`](crate::ast::DataType::Unspecified). #[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct SQLiteDialect {} impl Dialect for SQLiteDialect { // see https://www.sqlite.org/lang_keywords.html // parse `...`, [...] and "..." as identifier // TODO: support depending on the context tread '...' as identifier too. fn is_delimited_identifier_start(&self, ch: char) -> bool { ch == '`' || ch == '"' || ch == '[' } fn identifier_quote_style(&self, _identifier: &str) -> Option { Some('`') } fn is_identifier_start(&self, ch: char) -> bool { // See https://www.sqlite.org/draft/tokenreq.html ch.is_ascii_lowercase() || ch.is_ascii_uppercase() || ch == '_' || ('\u{007f}'..='\u{ffff}').contains(&ch) } fn supports_filter_during_aggregation(&self) -> bool { true } fn supports_start_transaction_modifier(&self) -> bool { true } fn is_identifier_part(&self, ch: char) -> bool { self.is_identifier_start(ch) || ch.is_ascii_digit() } fn parse_statement(&self, parser: &mut Parser) -> Option> { if parser.parse_keyword(Keyword::REPLACE) { parser.prev_token(); Some(parser.parse_insert(parser.get_current_token().clone())) } else { None } } fn parse_infix( &self, parser: &mut crate::parser::Parser, expr: &crate::ast::Expr, _precedence: u8, ) -> Option> { // Parse MATCH and REGEXP as operators // See 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(match parser.parse_expr() { Ok(expr) => expr, Err(e) => return Some(Err(e)), }); return Some(Ok(Expr::BinaryOp { left, op, right })); } } None } fn supports_in_empty_list(&self) -> bool { true } fn supports_limit_comma(&self) -> bool { true } fn supports_asc_desc_in_column_definition(&self) -> bool { true } fn supports_dollar_placeholder(&self) -> bool { true } /// SQLite supports `NOTNULL` as aliases for `IS NOT NULL` /// See: fn supports_notnull_operator(&self) -> bool { true } fn supports_comma_separated_trim(&self) -> bool { true } } apache-datafusion-sqlparser-rs-0.62.0/src/dialect/teradata.rs000066400000000000000000000102021517524037000241350ustar00rootroot00000000000000// 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 crate::dialect::Dialect; /// A [`Dialect`] for [Teradata](https://docs.teradata.com/). #[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct TeradataDialect; impl Dialect for TeradataDialect { /// See fn identifier_quote_style(&self, _identifier: &str) -> Option { Some('"') } /// See fn is_delimited_identifier_start(&self, ch: char) -> bool { ch == '"' } /// See fn is_identifier_start(&self, ch: char) -> bool { ch.is_alphabetic() || ch == '_' || ch == '#' || ch == '$' } // See fn is_identifier_part(&self, ch: char) -> bool { ch.is_alphanumeric() || self.is_identifier_start(ch) } /// See fn supports_group_by_expr(&self) -> bool { true } /// Teradata has no native `BOOLEAN` data type. /// /// See fn supports_boolean_literals(&self) -> bool { false } /// See fn require_interval_qualifier(&self) -> bool { true } /// See fn supports_comment_on(&self) -> bool { true } /// See fn supports_create_table_select(&self) -> bool { true } /// See fn supports_execute_immediate(&self) -> bool { true } /// See fn supports_top_before_distinct(&self) -> bool { true } /// See fn supports_window_function_null_treatment_arg(&self) -> bool { true } /// See fn supports_string_literal_concatenation(&self) -> bool { true } } apache-datafusion-sqlparser-rs-0.62.0/src/display_utils.rs000066400000000000000000000101061517524037000236330ustar00rootroot00000000000000// 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(pub T); const INDENT: &str = " "; impl Display for Indent 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 Write for Indent 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 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(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"); } } apache-datafusion-sqlparser-rs-0.62.0/src/keywords.rs000066400000000000000000000522251517524037000226250ustar00rootroot00000000000000// 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. //! 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. //! //! 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. #[cfg(feature = "serde")] use serde::{Deserialize, Serialize}; #[cfg(feature = "visitor")] use sqlparser_derive::{Visit, VisitMut}; /// Defines a string constant for a single keyword: `kw_def!(SELECT);` /// expands to `pub const SELECT = "SELECT";` macro_rules! kw_def { ($ident:ident = $string_keyword:expr) => { #[doc = concat!("The `", $string_keyword, "` SQL keyword.")] pub const $ident: &'static str = $string_keyword; }; ($ident:ident) => { kw_def!($ident = stringify!($ident)); }; } /// Expands to a list of `kw_def!()` invocations for each keyword /// and defines an ALL_KEYWORDS array of the defined constants. macro_rules! define_keywords { ($( $ident:ident $(= $string_keyword:expr)? ),*) => { #[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] #[allow(non_camel_case_types)] /// An enumeration of SQL keywords recognized by the parser. pub enum Keyword { /// Represents no keyword. NoKeyword, $( #[doc = concat!("The `", stringify!($ident), "` SQL keyword.")] $ident ),* } /// Array of all `Keyword` enum values in declaration order. pub const ALL_KEYWORDS_INDEX: &[Keyword] = &[ $(Keyword::$ident),* ]; $(kw_def!($ident $(= $string_keyword)?);)* /// Array of all SQL keywords as string constants. pub const ALL_KEYWORDS: &[&str] = &[ $($ident),* ]; impl core::fmt::Display for Keyword { fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { match self { Keyword::NoKeyword => write!(f, "NoKeyword"), $(Keyword::$ident => write!(f, "{}", $ident),)* } } } }; } // The following keywords should be sorted to be able to match using binary search define_keywords!( ABORT, ABS, ABSENT, ABSOLUTE, ACCEPTANYDATE, ACCEPTINVCHARS, ACCESS, ACCOUNT, ACTION, ADD, ADDQUOTES, ADMIN, AFTER, AGAINST, AGGREGATE, AGGREGATION, ALERT, ALGORITHM, ALIAS, ALIGNMENT, ALL, ALLOCATE, ALLOWOVERWRITE, ALTER, ALWAYS, ANALYZE, AND, ANTI, ANY, APPLICATION, APPLY, APPLYBUDGET, ARCHIVE, ARE, ARRAY, ARRAY_MAX_CARDINALITY, AS, ASC, ASENSITIVE, ASOF, ASSERT, ASYMMETRIC, AT, ATOMIC, ATTACH, AUDIT, AUTHENTICATION, AUTHORIZATION, AUTHORIZATIONS, AUTO, AUTOEXTEND_SIZE, AUTOINCREMENT, AUTO_INCREMENT, AVG, AVG_ROW_LENGTH, AVRO, BACKUP, BACKWARD, BASE64, BASE_LOCATION, BEFORE, BEGIN, BEGIN_FRAME, BEGIN_PARTITION, BERNOULLI, BETWEEN, BIGDECIMAL, BIGINT, BIGNUMERIC, BINARY, BIND, BINDING, BIT, BLANKSASNULL, BLOB, BLOCK, BLOOM, BLOOMFILTER, BOOL, BOOLEAN, BOOST, BOTH, BOX, BRIN, BROWSE, BTREE, BUCKET, BUCKETS, BY, BYPASSRLS, BYTEA, BYTES, BZIP2, CACHE, CALL, CALLED, CANONICAL, CARDINALITY, CASCADE, CASCADED, CASE, CASES, CAST, CATALOG, CATALOGS, CATALOG_SYNC, CATALOG_SYNC_NAMESPACE_FLATTEN_DELIMITER, CATALOG_SYNC_NAMESPACE_MODE, CATCH, CATEGORY, CEIL, CEILING, CENTURY, CHAIN, CHANGE, CHANGES, CHANGE_TRACKING, CHANNEL, CHAR, CHARACTER, CHARACTERISTICS, CHARACTERS, CHARACTER_LENGTH, CHARSET, CHAR_LENGTH, CHECK, CHECKSUM, CIRCLE, CLASS, CLEANPATH, CLEAR, CLOB, CLONE, CLOSE, CLUSTER, CLUSTERED, CLUSTERING, COALESCE, COLLATABLE, COLLATE, COLLATION, COLLECT, COLLECTION, COLUMN, COLUMNS, COLUMNSTORE, COMMENT, COMMIT, COMMITTED, COMMUTATOR, COMPATIBLE, COMPRESS, COMPRESSION, COMPUPDATE, COMPUTE, CONCURRENTLY, CONDITION, CONFLICT, CONNECT, CONNECTION, CONNECTOR, CONNECT_BY_ROOT, CONSTRAINT, CONTACT, CONTAINS, CONTINUE, CONVERT, COPY, COPY_OPTIONS, CORR, CORRESPONDING, COST, COUNT, COVAR_POP, COVAR_SAMP, CREATE, CREATEDB, CREATEROLE, CREDENTIALS, CROSS, CSV, CUBE, CUME_DIST, CURRENT, CURRENT_CATALOG, CURRENT_DATE, CURRENT_DEFAULT_TRANSFORM_GROUP, CURRENT_PATH, CURRENT_ROLE, CURRENT_ROW, CURRENT_SCHEMA, CURRENT_TIME, CURRENT_TIMESTAMP, CURRENT_TRANSFORM_GROUP_FOR_TYPE, CURRENT_USER, CURSOR, CYCLE, DATA, DATABASE, DATABASES, DATA_RETENTION_TIME_IN_DAYS, DATE, DATE32, DATEFORMAT, DATETIME, DATETIME64, DAY, DAYOFWEEK, DAYOFYEAR, DAYS, DCPROPERTIES, DEALLOCATE, DEC, DECADE, DECIMAL, DECLARE, DEDUPLICATE, DEFAULT, DEFAULTS, DEFAULT_DDL_COLLATION, DEFAULT_MFA_METHOD, DEFAULT_SECONDARY_ROLES, DEFERRABLE, DEFERRED, DEFINE, DEFINED, DEFINER, DELAY, DELAYED, DELAY_KEY_WRITE, DELEGATED, DELETE, DELIMITED, DELIMITER, DELTA, DENSE_RANK, DENY, DEPENDS, DEREF, DESC, DESCRIBE, DETACH, DETAIL, DETERMINISTIC, DIMENSIONS, DIRECTORY, DISABLE, DISCARD, DISCONNECT, DISTINCT, DISTINCTROW, DISTKEY, DISTRIBUTE, DISTSTYLE, DIV, DO, DOMAIN, DOUBLE, DOW, DOWNSTREAM, DOY, DROP, DRY, DUO, DUPLICATE, DYNAMIC, EACH, ELEMENT, ELEMENTS, ELSE, ELSEIF, EMPTY, EMPTYASNULL, ENABLE, ENABLE_SCHEMA_EVOLUTION, ENCODING, ENCRYPTED, ENCRYPTION, END, END_EXEC = "END-EXEC", ENDPOINT, END_FRAME, END_PARTITION, ENFORCED, ENGINE, ENGINE_ATTRIBUTE, ENROLL, ENUM, ENUM16, ENUM8, EPHEMERAL, EPOCH, EQUALS, ERROR, ESCAPE, ESCAPED, ESTIMATE, EVEN, EVENT, EVERY, EVOLVE, EXCEPT, EXCEPTION, EXCHANGE, EXCLUDE, EXCLUDING, EXCLUSIVE, EXEC, EXECUTE, EXECUTION, EXISTS, EXP, EXPANSION, EXPLAIN, EXPLICIT, EXPORT, EXTEND, EXTENDED, EXTENSION, EXTERNAL, EXTERNAL_VOLUME, EXTRACT, FACTS, FAIL, FAILOVER, FALSE, FAMILY, FETCH, FIELDS, FILE, FILES, FILE_FORMAT, FILL, FILTER, FINAL, FIRST, FIRST_VALUE, FIXEDSTRING, FIXEDWIDTH, FLATTEN, FLOAT, FLOAT32, FLOAT4, FLOAT64, FLOAT8, FLOOR, FLUSH, FN, FOLLOWING, FOR, FORCE, FORCE_NOT_NULL, FORCE_NULL, FORCE_QUOTE, FOREIGN, FORMAT, FORMATTED, FORWARD, FRAME_ROW, FREE, FREEZE, FROM, FSCK, FULFILLMENT, FULL, FULLTEXT, FUNCTION, FUNCTIONS, FUSION, FUTURE, GB, GENERAL, GENERATE, GENERATED, GEOGRAPHY, GET, GIN, GIST, GLOBAL, GRANT, GRANTED, GRANTS, GRAPHVIZ, GROUP, GROUPING, GROUPS, GZIP, HASH, HASHES, HAVING, HEADER, HEAP, HIGH_PRIORITY, HISTORY, HIVEVAR, HOLD, HOSTS, HOUR, HOURS, HUGEINT, IAM_ROLE, ICEBERG, ID, IDENTIFIED, IDENTITY, IDENTITY_INSERT, IF, IGNORE, IGNOREHEADER, ILIKE, IMMEDIATE, IMMUTABLE, IMPORT, IMPORTED, IN, INCLUDE, INCLUDE_NULL_VALUES, INCLUDING, INCREMENT, INCREMENTAL, INDEX, INDICATOR, INHERIT, INHERITS, INITIALIZE, INITIALLY, INNER, INOUT, INPATH, INPLACE, INPUT, INPUTFORMAT, INSENSITIVE, INSERT, INSERT_METHOD, INSTALL, INSTANT, INSTEAD, INT, INT128, INT16, INT2, INT256, INT32, INT4, INT64, INT8, INTEGER, INTEGRATION, INTERNALLENGTH, INTERPOLATE, INTERSECT, INTERSECTION, INTERVAL, INTO, INVISIBLE, INVOKER, IO, IS, ISODOW, ISOLATION, ISOWEEK, ISOYEAR, ITEMS, JAR, JOIN, JSON, JSONB, JSONFILE, JSON_TABLE, JULIAN, KEY, KEYS, KEY_BLOCK_SIZE, KILL, LAG, LAMBDA, LANGUAGE, LARGE, LAST, LAST_VALUE, LATERAL, LEAD, LEADING, LEAKPROOF, LEAST, LEFT, LEFTARG, LEVEL, LIFECYCLE, LIKE, LIKE_REGEX, LIMIT, LINE, LINES, LIST, LISTEN, LISTING, LN, LOAD, LOCAL, LOCALTIME, LOCALTIMESTAMP, LOCATION, LOCK, LOCKED, LOG, LOGIN, LOGS, LONG, LONGBLOB, LONGTEXT, LOWCARDINALITY, LOWER, LOW_PRIORITY, LS, LSEG, MACRO, MAIN, MANAGE, MANAGED, MANAGEDLOCATION, MANIFEST, MAP, MASKING, MATCH, MATCHED, MATCHES, MATCH_CONDITION, MATCH_RECOGNIZE, MATERIALIZE, MATERIALIZED, MAX, MAXFILESIZE, MAXVALUE, MAX_DATA_EXTENSION_TIME_IN_DAYS, MAX_ROWS, MB, MEASURES, MEDIUMBLOB, MEDIUMINT, MEDIUMTEXT, MEMBER, MERGE, MERGES, MESSAGE, METADATA, METHOD, METRIC, METRICS, MFA, MICROSECOND, MICROSECONDS, MILLENIUM, MILLENNIUM, MILLISECOND, MILLISECONDS, MIN, MINUS, MINUTE, MINUTES, MINVALUE, MIN_ROWS, MOD, MODE, MODIFIES, MODIFY, MODULE, MODULUS, MONITOR, MONTH, MONTHS, MSCK, MULTIRANGE_TYPE_NAME, MULTISET, MUTATION, NAME, NAMES, NANOSECOND, NANOSECONDS, NATIONAL, NATURAL, NCHAR, NCLOB, NEGATOR, NEST, NESTED, NETWORK, NEW, NEXT, NFC, NFD, NFKC, NFKD, NO, NOBYPASSRLS, NOCOMPRESS, NOCREATEDB, NOCREATEROLE, NOCYCLE, NOINHERIT, NOLOGIN, NONE, NOORDER, NOREPLICATION, NORMALIZE, NORMALIZED, NOSCAN, NOSUPERUSER, NOT, NOTHING, NOTIFY, NOTNULL, NOWAIT, NO_WRITE_TO_BINLOG, NTH_VALUE, NTILE, NULL, NULLABLE, NULLIF, NULLS, NUMBER, NUMERIC, NVARCHAR, OBJECT, OBJECTS, OCCURRENCES_REGEX, OCTETS, OCTET_LENGTH, OF, OFF, OFFSET, OFFSETS, OLD, OMIT, ON, ONE, ONLY, ON_CREATE, ON_SCHEDULE, OPEN, OPENJSON, OPERATE, OPERATOR, OPTIMIZATION, OPTIMIZE, OPTIMIZED, OPTIMIZER_COSTS, OPTION, OPTIONS, OR, ORC, ORDER, ORDINALITY, ORGANIZATION, OTHER, OTP, OUT, OUTER, OUTPUT, OUTPUTFORMAT, OVER, OVERFLOW, OVERLAPS, OVERLAY, OVERRIDE, OVERWRITE, OWNED, OWNER, OWNERSHIP, PACKAGE, PACKAGES, PACK_KEYS, PARALLEL, PARAMETER, PARQUET, PART, PARTIAL, PARTITION, PARTITIONED, PARTITIONS, PASSEDBYVALUE, PASSING, PASSKEY, PASSWORD, PAST, PATH, PATTERN, PCTFREE, PER, PERCENT, PERCENTILE_CONT, PERCENTILE_DISC, PERCENT_RANK, PERIOD, PERMISSIVE, PERSISTENT, PIVOT, PLACING, PLAIN, PLAN, PLANS, POINT, POLICY, POLYGON, POOL, PORTION, POSITION, POSITION_REGEX, POWER, PRAGMA, PRECEDES, PRECEDING, PRECISION, PREFERRED, PREPARE, PRESERVE, PRESET, PREWHERE, PRIMARY, PRINT, PRIOR, PRIVILEGES, PROCEDURE, PROCESSLIST, PROFILE, PROGRAM, PROJECTION, PUBLIC, PURCHASE, PURGE, QUALIFY, QUARTER, QUERIES, QUERY, QUOTE, RAISE, RAISERROR, RANGE, RANK, RAW, RCFILE, READ, READS, READ_ONLY, REAL, RECEIVE, RECLUSTER, RECURSIVE, REF, REFERENCES, REFERENCING, REFRESH, REFRESH_MODE, REGCLASS, REGEXP, REGION, REGR_AVGX, REGR_AVGY, REGR_COUNT, REGR_INTERCEPT, REGR_R2, REGR_SLOPE, REGR_SXX, REGR_SXY, REGR_SYY, REINDEX, RELATIVE, RELAY, RELEASE, RELEASES, REMAINDER, REMOTE, REMOVE, REMOVEQUOTES, RENAME, REORG, REPAIR, REPEATABLE, REPLACE, REPLACE_INVALID_CHARACTERS, REPLICA, REPLICATE, REPLICATION, REQUIRE, RESET, RESOLVE, RESOURCE, RESPECT, RESTART, RESTRICT, RESTRICTED, RESTRICTIONS, RESTRICTIVE, RESULT, RESULTSET, RESUME, RETAIN, RETURN, RETURNING, RETURNS, REVOKE, RIGHT, RIGHTARG, RLIKE, RM, ROLE, ROLES, ROLLBACK, ROLLUP, ROOT, ROW, ROWGROUPSIZE, ROWID, ROWS, ROW_FORMAT, ROW_NUMBER, RULE, RUN, SAFE, SAFE_CAST, SAMPLE, SAVEPOINT, SCHEMA, SCHEMAS, SCOPE, SCROLL, SEARCH, SECOND, SECONDARY, SECONDARY_ENGINE_ATTRIBUTE, SECONDS, SECRET, SECURE, SECURITY, SEED, SELECT, SEMANTIC_VIEW, SEMI, SEND, SENSITIVE, SEPARATOR, SEQUENCE, SEQUENCEFILE, SEQUENCES, SERDE, SERDEPROPERTIES, SERIALIZABLE, SERVER, SERVICE, SESSION, SESSION_USER, SET, SETERROR, SETOF, SETS, SETTINGS, SHARE, SHARED, SHARING, SHOW, SIGNED, SIMILAR, SIMPLE, SIZE, SKIP, SLOW, SMALLINT, SNAPSHOT, SOME, SORT, SORTED, SORTKEY, SOURCE, SPATIAL, SPECIFIC, SPECIFICTYPE, SPGIST, SQL, SQLEXCEPTION, SQLSTATE, SQLWARNING, SQL_BIG_RESULT, SQL_BUFFER_RESULT, SQL_CALC_FOUND_ROWS, SQL_NO_CACHE, SQL_SMALL_RESULT, SQRT, SRID, STABLE, STAGE, START, STARTS, STATEMENT, STATIC, STATISTICS, STATS_AUTO_RECALC, STATS_PERSISTENT, STATS_SAMPLE_PAGES, STATUPDATE, STATUS, STDDEV_POP, STDDEV_SAMP, STDIN, STDOUT, STEP, STORAGE, STORAGE_INTEGRATION, STORAGE_SERIALIZATION_POLICY, STORED, STRAIGHT_JOIN, STREAM, STRICT, STRING, STRUCT, SUBMULTISET, SUBSCRIPT, SUBSTR, SUBSTRING, SUBSTRING_REGEX, SUBTYPE, SUBTYPE_DIFF, SUBTYPE_OPCLASS, SUCCEEDS, SUM, SUPER, SUPERUSER, SUPPORT, SUSPEND, SWAP, SYMMETRIC, SYNC, SYNONYM, SYSTEM, SYSTEM_TIME, SYSTEM_USER, TABLE, TABLES, TABLESAMPLE, TABLESPACE, TAG, TARGET, TARGET_LAG, TASK, TBLPROPERTIES, TEMP, TEMPORARY, TEMPTABLE, TERMINATED, TERSE, TEXT, TEXTFILE, THEN, THROW, TIES, TIME, TIMEFORMAT, TIMESTAMP, TIMESTAMPTZ, TIMESTAMP_NTZ, TIMETZ, TIMEZONE, TIMEZONE_ABBR, TIMEZONE_HOUR, TIMEZONE_MINUTE, TIMEZONE_REGION, TINYBLOB, TINYINT, TINYTEXT, TO, TOP, TOTALS, TOTP, TRACE, TRAILING, TRAN, TRANSACTION, TRANSIENT, TRANSLATE, TRANSLATE_REGEX, TRANSLATION, TREAT, TREE, TRIGGER, TRIM, TRIM_ARRAY, TRUE, TRUNCATE, TRUNCATECOLUMNS, TRY, TRY_CAST, TRY_CONVERT, TSQUERY, TSVECTOR, TUPLE, TYPE, TYPMOD_IN, TYPMOD_OUT, UBIGINT, UESCAPE, UHUGEINT, UINT128, UINT16, UINT256, UINT32, UINT64, UINT8, UNBOUNDED, UNCACHE, UNCOMMITTED, UNDEFINED, UNFREEZE, UNION, UNIQUE, UNKNOWN, UNLISTEN, UNLOAD, UNLOCK, UNLOGGED, UNMATCHED, UNNEST, UNPIVOT, UNSAFE, UNSET, UNSIGNED, UNTIL, UPDATE, UPPER, URL, USAGE, USE, USER, USER_RESOURCES, USING, USMALLINT, UTINYINT, UUID, VACUUM, VALID, VALIDATE, VALIDATION_MODE, VALUE, VALUES, VALUE_OF, VARBINARY, VARBIT, VARCHAR, VARCHAR2, VARIABLE, VARIABLES, VARIADIC, VARYING, VAR_POP, VAR_SAMP, VERBOSE, VERSION, VERSIONING, VERSIONS, VIEW, VIEWS, VIRTUAL, VOLATILE, VOLUME, WAITFOR, WAREHOUSE, WAREHOUSES, WEEK, WEEKS, WHEN, WHENEVER, WHERE, WHILE, WIDTH_BUCKET, WINDOW, WITH, WITHIN, WITHOUT, WITHOUT_ARRAY_WRAPPER, WORK, WORKLOAD_IDENTITY, WRAPPER, WRITE, XML, XMLNAMESPACES, XMLTABLE, XOR, YEAR, YEARS, YES, ZONE, ZORDER, ZSTD ); /// These keywords can't be used as a table alias, so that `FROM table_name alias` /// can be parsed unambiguously without looking ahead. pub const RESERVED_FOR_TABLE_ALIAS: &[Keyword] = &[ // Reserved as both a table and a column alias: Keyword::WITH, Keyword::EXPLAIN, Keyword::ANALYZE, Keyword::SELECT, Keyword::WHERE, Keyword::GROUP, Keyword::SORT, Keyword::HAVING, Keyword::ORDER, Keyword::PIVOT, Keyword::UNPIVOT, Keyword::TOP, Keyword::LATERAL, Keyword::VIEW, Keyword::LIMIT, Keyword::OFFSET, Keyword::FETCH, Keyword::UNION, Keyword::EXCEPT, Keyword::INTERSECT, Keyword::MINUS, // Reserved only as a table alias in the `FROM`/`JOIN` clauses: Keyword::ON, Keyword::JOIN, Keyword::INNER, Keyword::CROSS, Keyword::FULL, Keyword::LEFT, Keyword::RIGHT, Keyword::NATURAL, Keyword::USING, Keyword::CLUSTER, Keyword::DISTRIBUTE, Keyword::GLOBAL, Keyword::ANTI, Keyword::SEMI, Keyword::RETURNING, Keyword::OUTPUT, Keyword::ASOF, Keyword::MATCH_CONDITION, // for MSSQL-specific OUTER APPLY (seems reserved in most dialects) Keyword::OUTER, Keyword::SET, Keyword::QUALIFY, Keyword::WINDOW, Keyword::END, Keyword::FOR, // for MYSQL PARTITION SELECTION Keyword::PARTITION, // for Clickhouse ARRAY JOIN (ARRAY must not be parsed as a table alias) Keyword::ARRAY, // for Clickhouse PREWHERE Keyword::PREWHERE, Keyword::SETTINGS, 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 alias` /// can be parsed unambiguously without looking ahead. pub const RESERVED_FOR_COLUMN_ALIAS: &[Keyword] = &[ // Reserved as both a table and a column alias: Keyword::WITH, Keyword::EXPLAIN, Keyword::ANALYZE, Keyword::SELECT, Keyword::WHERE, Keyword::GROUP, Keyword::SORT, Keyword::HAVING, Keyword::ORDER, Keyword::TOP, Keyword::LATERAL, Keyword::VIEW, Keyword::LIMIT, Keyword::OFFSET, Keyword::FETCH, Keyword::UNION, Keyword::EXCEPT, Keyword::EXCLUDE, Keyword::INTERSECT, Keyword::MINUS, Keyword::CLUSTER, Keyword::DISTRIBUTE, Keyword::RETURNING, Keyword::VALUES, // Reserved only as a column alias in the `SELECT` clause Keyword::FROM, 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, ]; apache-datafusion-sqlparser-rs-0.62.0/src/lib.rs000066400000000000000000000137151517524037000215250ustar00rootroot00000000000000// 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. //! # SQL Parser for Rust //! //! This crate provides an ANSI:SQL 2011 lexer and parser that can parse SQL //! into an Abstract Syntax Tree ([`AST`]). See the [sqlparser crates.io page] //! for more information. //! //! For more information: //! 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 //! //! ``` //! use sqlparser::dialect::GenericDialect; //! use sqlparser::parser::Parser; //! //! let dialect = GenericDialect {}; // or AnsiDialect //! //! let sql = "SELECT a, b, 123, myfunc(b) \ //! FROM table_1 \ //! WHERE a > b AND b < 100 \ //! ORDER BY a DESC, b"; //! //! let ast = Parser::parse_sql(&dialect, sql).unwrap(); //! //! println!("AST: {:?}", ast); //! ``` //! //! # Creating SQL text from AST //! //! This crate allows users to recover the original SQL text (with comments //! removed, normalized whitespace and identifier capitalization), which is //! useful for tools that analyze and manipulate SQL. //! //! ``` //! # use sqlparser::dialect::GenericDialect; //! # use sqlparser::parser::Parser; //! let sql = "SELECT a FROM table_1"; //! //! // parse to a Vec //! 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); //! ``` //! //! # 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)] #![forbid(clippy::unreachable)] #![forbid(missing_docs)] // Allow proc-macros to find this crate extern crate self as sqlparser; #[cfg(not(feature = "std"))] extern crate alloc; #[macro_use] #[cfg(test)] extern crate pretty_assertions; pub mod ast; #[macro_use] /// Submodules for SQL dialects. pub mod dialect; #[cfg(feature = "derive-dialect")] pub use dialect::derive_dialect; mod display_utils; pub mod keywords; pub mod parser; pub mod tokenizer; #[doc(hidden)] // This is required to make utilities accessible by both the crate-internal // unit-tests and by the integration tests // External users are not supposed to rely on this module. pub mod test_utils; apache-datafusion-sqlparser-rs-0.62.0/src/parser/000077500000000000000000000000001517524037000216765ustar00rootroot00000000000000apache-datafusion-sqlparser-rs-0.62.0/src/parser/alter.rs000066400000000000000000000462331517524037000233630ustar00rootroot00000000000000// Licensed 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. //! SQL Parser for ALTER #[cfg(not(feature = "std"))] use alloc::{string::ToString, vec}; use super::{Parser, ParserError}; use crate::{ ast::{ helpers::key_value_options::{KeyValueOptions, KeyValueOptionsDelimiter}, AlterConnectorOwner, AlterPolicy, AlterPolicyOperation, AlterRoleOperation, AlterUser, AlterUserAddMfaMethodOtp, AlterUserAddRoleDelegation, AlterUserModifyMfaMethod, AlterUserPassword, AlterUserRemoveRoleDelegation, AlterUserSetPolicy, Expr, MfaMethodKind, Password, ResetConfig, RoleOption, SetConfigValue, Statement, UserPolicyKind, }, dialect::{MsSqlDialect, PostgreSqlDialect}, keywords::Keyword, tokenizer::Token, }; impl Parser<'_> { /// Parse `ALTER ROLE` statement pub fn parse_alter_role(&mut self) -> Result { if dialect_of!(self is PostgreSqlDialect) { return self.parse_pg_alter_role(); } else if dialect_of!(self is MsSqlDialect) { return self.parse_mssql_alter_role(); } Err(ParserError::ParserError( "ALTER ROLE is only support for PostgreSqlDialect, MsSqlDialect".into(), )) } /// Parse ALTER POLICY statement /// ```sql /// ALTER POLICY policy_name ON table_name [ RENAME TO new_name ] /// or /// ALTER POLICY policy_name ON table_name /// [ TO { role_name | PUBLIC | CURRENT_ROLE | CURRENT_USER | SESSION_USER } [, ...] ] /// [ USING ( using_expression ) ] /// [ WITH CHECK ( check_expression ) ] /// ``` /// /// [PostgreSQL](https://www.postgresql.org/docs/current/sql-alterpolicy.html) pub fn parse_alter_policy(&mut self) -> Result { let name = self.parse_identifier()?; self.expect_keyword_is(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()?; Ok(AlterPolicy { name, table_name, operation: AlterPolicyOperation::Rename { new_name }, }) } else { let to = if self.parse_keyword(Keyword::TO) { Some(self.parse_comma_separated(|p| p.parse_owner())?) } else { None }; let using = if self.parse_keyword(Keyword::USING) { self.expect_token(&Token::LParen)?; let expr = self.parse_expr()?; self.expect_token(&Token::RParen)?; Some(expr) } else { None }; let with_check = if self.parse_keywords(&[Keyword::WITH, Keyword::CHECK]) { self.expect_token(&Token::LParen)?; let expr = self.parse_expr()?; self.expect_token(&Token::RParen)?; Some(expr) } else { None }; Ok(AlterPolicy { name, table_name, operation: AlterPolicyOperation::Apply { to, using, with_check, }, }) } } /// 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 { 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, }) } /// Parse an `ALTER USER` statement /// ```sql /// ALTER USER [ IF EXISTS ] [ ] [ OPTIONS ] /// ``` pub fn parse_alter_user(&mut self) -> Result { let if_exists = self.parse_keywords(&[Keyword::IF, Keyword::EXISTS]); let name = self.parse_identifier()?; let _ = self.parse_keyword(Keyword::WITH); let rename_to = if self.parse_keywords(&[Keyword::RENAME, Keyword::TO]) { Some(self.parse_identifier()?) } else { None }; let reset_password = self.parse_keywords(&[Keyword::RESET, Keyword::PASSWORD]); let abort_all_queries = self.parse_keywords(&[Keyword::ABORT, Keyword::ALL, Keyword::QUERIES]); let add_role_delegation = if self.parse_keywords(&[ Keyword::ADD, Keyword::DELEGATED, Keyword::AUTHORIZATION, Keyword::OF, Keyword::ROLE, ]) { let role = self.parse_identifier()?; self.expect_keywords(&[Keyword::TO, Keyword::SECURITY, Keyword::INTEGRATION])?; let integration = self.parse_identifier()?; Some(AlterUserAddRoleDelegation { role, integration }) } else { None }; let remove_role_delegation = if self.parse_keywords(&[Keyword::REMOVE, Keyword::DELEGATED]) { let role = if self.parse_keywords(&[Keyword::AUTHORIZATION, Keyword::OF, Keyword::ROLE]) { Some(self.parse_identifier()?) } else if self.parse_keyword(Keyword::AUTHORIZATIONS) { None } else { return self.expected_ref( "REMOVE DELEGATED AUTHORIZATION OF ROLE | REMOVE DELEGATED AUTHORIZATIONS", self.peek_token_ref(), ); }; self.expect_keywords(&[Keyword::FROM, Keyword::SECURITY, Keyword::INTEGRATION])?; let integration = self.parse_identifier()?; Some(AlterUserRemoveRoleDelegation { role, integration }) } else { None }; let enroll_mfa = self.parse_keywords(&[Keyword::ENROLL, Keyword::MFA]); let set_default_mfa_method = if self.parse_keywords(&[Keyword::SET, Keyword::DEFAULT_MFA_METHOD]) { Some(self.parse_mfa_method()?) } else { None }; let remove_mfa_method = if self.parse_keywords(&[Keyword::REMOVE, Keyword::MFA, Keyword::METHOD]) { Some(self.parse_mfa_method()?) } else { None }; let modify_mfa_method = if self.parse_keywords(&[Keyword::MODIFY, Keyword::MFA, Keyword::METHOD]) { let method = self.parse_mfa_method()?; self.expect_keywords(&[Keyword::SET, Keyword::COMMENT])?; let comment = self.parse_literal_string()?; Some(AlterUserModifyMfaMethod { method, comment }) } else { None }; let add_mfa_method_otp = if self.parse_keywords(&[Keyword::ADD, Keyword::MFA, Keyword::METHOD, Keyword::OTP]) { let count = if self.parse_keyword(Keyword::COUNT) { self.expect_token(&Token::Eq)?; Some(self.parse_value()?) } else { None }; Some(AlterUserAddMfaMethodOtp { count }) } else { None }; let set_policy = if self.parse_keywords(&[Keyword::SET, Keyword::AUTHENTICATION, Keyword::POLICY]) { Some(AlterUserSetPolicy { policy_kind: UserPolicyKind::Authentication, policy: self.parse_identifier()?, }) } else if self.parse_keywords(&[Keyword::SET, Keyword::PASSWORD, Keyword::POLICY]) { Some(AlterUserSetPolicy { policy_kind: UserPolicyKind::Password, policy: self.parse_identifier()?, }) } else if self.parse_keywords(&[Keyword::SET, Keyword::SESSION, Keyword::POLICY]) { Some(AlterUserSetPolicy { policy_kind: UserPolicyKind::Session, policy: self.parse_identifier()?, }) } else { None }; let unset_policy = if self.parse_keywords(&[Keyword::UNSET, Keyword::AUTHENTICATION, Keyword::POLICY]) { Some(UserPolicyKind::Authentication) } else if self.parse_keywords(&[Keyword::UNSET, Keyword::PASSWORD, Keyword::POLICY]) { Some(UserPolicyKind::Password) } else if self.parse_keywords(&[Keyword::UNSET, Keyword::SESSION, Keyword::POLICY]) { Some(UserPolicyKind::Session) } else { None }; let set_tag = if self.parse_keywords(&[Keyword::SET, Keyword::TAG]) { self.parse_key_value_options(false, &[])? } else { KeyValueOptions { delimiter: KeyValueOptionsDelimiter::Comma, options: vec![], } }; let unset_tag = if self.parse_keywords(&[Keyword::UNSET, Keyword::TAG]) { self.parse_comma_separated(Parser::parse_identifier)? .iter() .map(|i| i.to_string()) .collect() } else { vec![] }; let set_props = if self.parse_keyword(Keyword::SET) { self.parse_key_value_options(false, &[])? } else { KeyValueOptions { delimiter: KeyValueOptionsDelimiter::Comma, options: vec![], } }; let unset_props = if self.parse_keyword(Keyword::UNSET) { self.parse_comma_separated(Parser::parse_identifier)? .iter() .map(|i| i.to_string()) .collect() } else { vec![] }; let encrypted = self.parse_keyword(Keyword::ENCRYPTED); let password = if self.parse_keyword(Keyword::PASSWORD) { let password = if self.parse_keyword(Keyword::NULL) { None } else { Some(self.parse_literal_string()?) }; Some(AlterUserPassword { encrypted, password, }) } else { None }; Ok(AlterUser { if_exists, name, rename_to, reset_password, abort_all_queries, add_role_delegation, remove_role_delegation, enroll_mfa, set_default_mfa_method, remove_mfa_method, modify_mfa_method, add_mfa_method_otp, set_policy, unset_policy, set_tag, unset_tag, set_props, unset_props, password, }) } fn parse_mfa_method(&mut self) -> Result { if self.parse_keyword(Keyword::PASSKEY) { Ok(MfaMethodKind::PassKey) } else if self.parse_keyword(Keyword::TOTP) { Ok(MfaMethodKind::Totp) } else if self.parse_keyword(Keyword::DUO) { Ok(MfaMethodKind::Duo) } else { self.expected_ref("PASSKEY, TOTP or DUO", self.peek_token_ref()) } } fn parse_mssql_alter_role(&mut self) -> Result { let role_name = self.parse_identifier()?; let operation = if self.parse_keywords(&[Keyword::ADD, Keyword::MEMBER]) { let member_name = self.parse_identifier()?; AlterRoleOperation::AddMember { member_name } } else if self.parse_keywords(&[Keyword::DROP, Keyword::MEMBER]) { let member_name = self.parse_identifier()?; 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()?; AlterRoleOperation::RenameRole { role_name } } else { return self.expected_ref("= after WITH NAME ", self.peek_token_ref()); } } else { return self.expected_ref("'ADD' or 'DROP' or 'WITH NAME'", self.peek_token_ref()); }; Ok(Statement::AlterRole { name: role_name, operation, }) } fn parse_pg_alter_role(&mut self) -> Result { let role_name = self.parse_identifier()?; // [ IN DATABASE _`database_name`_ ] let in_database = if self.parse_keywords(&[Keyword::IN, Keyword::DATABASE]) { self.parse_object_name(false).ok() } else { None }; let operation = if self.parse_keyword(Keyword::RENAME) { if self.parse_keyword(Keyword::TO) { let role_name = self.parse_identifier()?; AlterRoleOperation::RenameRole { role_name } } else { return self.expected_ref("TO after RENAME", self.peek_token_ref()); } // SET } else if self.parse_keyword(Keyword::SET) { let config_name = self.parse_object_name(false)?; // FROM CURRENT if self.parse_keywords(&[Keyword::FROM, Keyword::CURRENT]) { AlterRoleOperation::Set { config_name, config_value: SetConfigValue::FromCurrent, in_database, } // { TO | = } { value | DEFAULT } } else if self.consume_token(&Token::Eq) || self.parse_keyword(Keyword::TO) { if self.parse_keyword(Keyword::DEFAULT) { AlterRoleOperation::Set { config_name, config_value: SetConfigValue::Default, in_database, } } else if let Ok(expr) = self.parse_expr() { AlterRoleOperation::Set { config_name, config_value: SetConfigValue::Value(expr), in_database, } } else { self.expected_ref("config value", self.peek_token_ref())? } } else { self.expected_ref("'TO' or '=' or 'FROM CURRENT'", self.peek_token_ref())? } // RESET } else if self.parse_keyword(Keyword::RESET) { if self.parse_keyword(Keyword::ALL) { AlterRoleOperation::Reset { config_name: ResetConfig::ALL, in_database, } } else { let config_name = self.parse_object_name(false)?; AlterRoleOperation::Reset { config_name: ResetConfig::ConfigName(config_name), in_database, } } // option } else { // [ WITH ] let _ = self.parse_keyword(Keyword::WITH); // option let mut options = vec![]; while let Some(opt) = self.maybe_parse(|parser| parser.parse_pg_role_option())? { options.push(opt); } // check option if options.is_empty() { return self.expected_ref("option", self.peek_token_ref())?; } AlterRoleOperation::WithOptions { options } }; Ok(Statement::AlterRole { name: role_name, operation, }) } fn parse_pg_role_option(&mut self) -> Result { let option = match self.parse_one_of_keywords(&[ Keyword::BYPASSRLS, Keyword::NOBYPASSRLS, Keyword::CONNECTION, Keyword::CREATEDB, Keyword::NOCREATEDB, Keyword::CREATEROLE, Keyword::NOCREATEROLE, Keyword::INHERIT, Keyword::NOINHERIT, Keyword::LOGIN, Keyword::NOLOGIN, Keyword::PASSWORD, Keyword::REPLICATION, Keyword::NOREPLICATION, Keyword::SUPERUSER, Keyword::NOSUPERUSER, Keyword::VALID, ]) { Some(Keyword::BYPASSRLS) => RoleOption::BypassRLS(true), Some(Keyword::NOBYPASSRLS) => RoleOption::BypassRLS(false), Some(Keyword::CONNECTION) => { self.expect_keyword_is(Keyword::LIMIT)?; RoleOption::ConnectionLimit(Expr::Value(self.parse_number_value()?)) } Some(Keyword::CREATEDB) => RoleOption::CreateDB(true), Some(Keyword::NOCREATEDB) => RoleOption::CreateDB(false), Some(Keyword::CREATEROLE) => RoleOption::CreateRole(true), Some(Keyword::NOCREATEROLE) => RoleOption::CreateRole(false), Some(Keyword::INHERIT) => RoleOption::Inherit(true), Some(Keyword::NOINHERIT) => RoleOption::Inherit(false), Some(Keyword::LOGIN) => RoleOption::Login(true), Some(Keyword::NOLOGIN) => RoleOption::Login(false), Some(Keyword::PASSWORD) => { let password = if self.parse_keyword(Keyword::NULL) { Password::NullPassword } else { Password::Password(Expr::Value(self.parse_value()?)) }; RoleOption::Password(password) } Some(Keyword::REPLICATION) => RoleOption::Replication(true), Some(Keyword::NOREPLICATION) => RoleOption::Replication(false), Some(Keyword::SUPERUSER) => RoleOption::SuperUser(true), Some(Keyword::NOSUPERUSER) => RoleOption::SuperUser(false), Some(Keyword::VALID) => { self.expect_keyword_is(Keyword::UNTIL)?; RoleOption::ValidUntil(Expr::Value(self.parse_value()?)) } _ => self.expected_ref("option", self.peek_token_ref())?, }; Ok(option) } } apache-datafusion-sqlparser-rs-0.62.0/src/parser/merge.rs000066400000000000000000000231571517524037000233530ustar00rootroot00000000000000// Licensed 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. //! SQL Parser for a `MERGE` statement #[cfg(not(feature = "std"))] use alloc::{boxed::Box, format, vec, vec::Vec}; use crate::{ ast::{ Merge, MergeAction, MergeClause, MergeClauseKind, MergeInsertExpr, MergeInsertKind, MergeUpdateExpr, ObjectName, OutputClause, SetExpr, }, dialect::{BigQueryDialect, GenericDialect, MySqlDialect}, keywords::Keyword, parser::IsOptional, tokenizer::TokenWithSpan, }; use super::{Parser, ParserError}; impl Parser<'_> { /// Parse a `MERGE` statement, returning a `Box`ed SetExpr /// /// This is used to reduce the size of the stack frames in debug builds pub(super) fn parse_merge_setexpr_boxed( &mut self, merge_token: TokenWithSpan, ) -> Result, ParserError> { Ok(Box::new(SetExpr::Merge( self.parse_merge(merge_token)?.into(), ))) } /// Parse a `MERGE` statement pub fn parse_merge(&mut self, merge_token: TokenWithSpan) -> Result { let optimizer_hints = self.maybe_parse_optimizer_hints()?; let into = self.parse_keyword(Keyword::INTO); let table = self.parse_table_factor()?; self.expect_keyword_is(Keyword::USING)?; let source = self.parse_table_factor()?; self.expect_keyword_is(Keyword::ON)?; let on = self.parse_expr()?; let clauses = self.parse_merge_clauses()?; let output = match self.parse_one_of_keywords(&[Keyword::OUTPUT, Keyword::RETURNING]) { Some(keyword) => Some(self.parse_output(keyword, self.get_current_token().clone())?), None => None, }; Ok(Merge { merge_token: merge_token.into(), optimizer_hints, into, table, source, on: Box::new(on), clauses, output, }) } fn parse_merge_clauses(&mut self) -> Result, ParserError> { let mut clauses = vec![]; loop { if !(self.parse_keyword(Keyword::WHEN)) { break; } let when_token = self.get_current_token().clone(); let mut clause_kind = MergeClauseKind::Matched; if self.parse_keyword(Keyword::NOT) { clause_kind = MergeClauseKind::NotMatched; } self.expect_keyword_is(Keyword::MATCHED)?; if matches!(clause_kind, MergeClauseKind::NotMatched) && self.parse_keywords(&[Keyword::BY, Keyword::SOURCE]) { clause_kind = MergeClauseKind::NotMatchedBySource; } else if matches!(clause_kind, MergeClauseKind::NotMatched) && self.parse_keywords(&[Keyword::BY, Keyword::TARGET]) { clause_kind = MergeClauseKind::NotMatchedByTarget; } let predicate = if self.parse_keyword(Keyword::AND) { Some(self.parse_expr()?) } else { None }; self.expect_keyword_is(Keyword::THEN)?; let merge_clause = match self.parse_one_of_keywords(&[ Keyword::UPDATE, Keyword::INSERT, Keyword::DELETE, ]) { Some(Keyword::UPDATE) => { if matches!( clause_kind, MergeClauseKind::NotMatched | MergeClauseKind::NotMatchedByTarget ) { return parser_err!( format_args!("UPDATE is not allowed in a {clause_kind} merge clause"), self.get_current_token().span.start ); } let update_token = self.get_current_token().clone(); self.expect_keyword_is(Keyword::SET)?; let assignments = self.parse_comma_separated(Parser::parse_assignment)?; let update_predicate = if self.parse_keyword(Keyword::WHERE) { Some(self.parse_expr()?) } else { None }; let delete_predicate = if self.parse_keyword(Keyword::DELETE) { let _ = self.expect_keyword(Keyword::WHERE)?; Some(self.parse_expr()?) } else { None }; MergeAction::Update(MergeUpdateExpr { update_token: update_token.into(), assignments, update_predicate, delete_predicate, }) } Some(Keyword::DELETE) => { if matches!( clause_kind, MergeClauseKind::NotMatched | MergeClauseKind::NotMatchedByTarget ) { return parser_err!( format_args!("DELETE is not allowed in a {clause_kind} merge clause"), self.get_current_token().span.start ); }; let delete_token = self.get_current_token().clone(); MergeAction::Delete { delete_token: delete_token.into(), } } Some(Keyword::INSERT) => { if !matches!( clause_kind, MergeClauseKind::NotMatched | MergeClauseKind::NotMatchedByTarget ) { return parser_err!( format_args!("INSERT is not allowed in a {clause_kind} merge clause"), self.get_current_token().span.start ); }; let insert_token = self.get_current_token().clone(); let is_mysql = dialect_of!(self is MySqlDialect); let columns = self.parse_merge_clause_insert_columns(is_mysql)?; let (kind, kind_token) = if dialect_of!(self is BigQueryDialect | GenericDialect) && self.parse_keyword(Keyword::ROW) { (MergeInsertKind::Row, self.get_current_token().clone()) } else { self.expect_keyword_is(Keyword::VALUES)?; let values_token = self.get_current_token().clone(); let values = self.parse_values(is_mysql, false)?; (MergeInsertKind::Values(values), values_token) }; let insert_predicate = if self.parse_keyword(Keyword::WHERE) { Some(self.parse_expr()?) } else { None }; MergeAction::Insert(MergeInsertExpr { insert_token: insert_token.into(), columns, kind_token: kind_token.into(), kind, insert_predicate, }) } _ => { return parser_err!( "expected UPDATE, DELETE or INSERT in merge clause", self.peek_token_ref().span.start ); } }; clauses.push(MergeClause { when_token: when_token.into(), clause_kind, predicate, action: merge_clause, }); } Ok(clauses) } fn parse_merge_clause_insert_columns( &mut self, allow_empty: bool, ) -> Result, ParserError> { self.parse_parenthesized_qualified_column_list(IsOptional::Optional, allow_empty) } /// Parses an `OUTPUT` clause if present (MSSQL). pub(super) fn maybe_parse_output_clause( &mut self, ) -> Result, ParserError> { if self.parse_keyword(Keyword::OUTPUT) { Ok(Some(self.parse_output( Keyword::OUTPUT, self.get_current_token().clone(), )?)) } else { Ok(None) } } pub(super) fn parse_output( &mut self, start_keyword: Keyword, start_token: TokenWithSpan, ) -> Result { let select_items = self.parse_projection()?; let into_table = if start_keyword == Keyword::OUTPUT && self.peek_keyword(Keyword::INTO) { self.expect_keyword_is(Keyword::INTO)?; Some(self.parse_select_into()?) } else { None }; Ok(if start_keyword == Keyword::OUTPUT { OutputClause::Output { output_token: start_token.into(), select_items, into_table, } } else { OutputClause::Returning { returning_token: start_token.into(), select_items, } }) } } apache-datafusion-sqlparser-rs-0.62.0/src/parser/mod.rs000066400000000000000000031705501517524037000230360ustar00rootroot00000000000000// Licensed 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. //! SQL Parser #[cfg(not(feature = "std"))] use alloc::{ boxed::Box, format, string::{String, ToString}, vec, vec::Vec, }; use core::{ fmt::{self, Display}, str::FromStr, }; use helpers::attached_token::AttachedToken; use log::debug; use recursion::RecursionCounter; use IsLateral::*; use IsOptional::*; use crate::ast::*; use crate::ast::{ comments, helpers::{ key_value_options::{ KeyValueOption, KeyValueOptionKind, KeyValueOptions, KeyValueOptionsDelimiter, }, stmt_create_table::{CreateTableBuilder, CreateTableConfiguration}, }, }; use crate::dialect::*; use crate::keywords::{Keyword, ALL_KEYWORDS}; use crate::tokenizer::*; use sqlparser::parser::ParserState::ColumnDefinition; /// Errors produced by the SQL parser. #[derive(Debug, Clone, PartialEq, Eq)] pub enum ParserError { /// Error originating from the tokenizer with a message. TokenizerError(String), /// Generic parser error with a message. ParserError(String), /// Raised when a recursion depth limit is exceeded. RecursionLimitExceeded, } // Use `Parser::expected` instead, if possible macro_rules! parser_err { ($MSG:expr, $loc:expr) => { Err(ParserError::ParserError(format!("{}{}", $MSG, $loc))) }; } mod alter; mod merge; #[cfg(feature = "std")] /// Implementation [`RecursionCounter`] if std is available mod recursion { use std::cell::Cell; use std::rc::Rc; use super::ParserError; /// Tracks remaining recursion depth. This value is decremented on /// each call to [`RecursionCounter::try_decrease()`], when it reaches 0 an error will /// be returned. /// /// Note: Uses an [`std::rc::Rc`] and [`std::cell::Cell`] in order to satisfy the Rust /// borrow checker so the automatic [`DepthGuard`] decrement a /// reference to the counter. /// /// Note: when "recursive-protection" feature is enabled, this crate uses additional stack overflow protection /// for some of its recursive methods. See [`recursive::recursive`] for more information. pub(crate) struct RecursionCounter { remaining_depth: Rc>, } impl RecursionCounter { /// Creates a [`RecursionCounter`] with the specified maximum /// depth pub fn new(remaining_depth: usize) -> Self { Self { remaining_depth: Rc::new(remaining_depth.into()), } } /// Decreases the remaining depth by 1. /// /// Returns [`Err`] if the remaining depth falls to 0. /// /// Returns a [`DepthGuard`] which will adds 1 to the /// remaining depth upon drop; pub fn try_decrease(&self) -> Result { let old_value = self.remaining_depth.get(); // ran out of space if old_value == 0 { Err(ParserError::RecursionLimitExceeded) } else { self.remaining_depth.set(old_value - 1); Ok(DepthGuard::new(Rc::clone(&self.remaining_depth))) } } } /// Guard that increases the remaining depth by 1 on drop pub struct DepthGuard { remaining_depth: Rc>, } impl DepthGuard { fn new(remaining_depth: Rc>) -> Self { Self { remaining_depth } } } impl Drop for DepthGuard { fn drop(&mut self) { let old_value = self.remaining_depth.get(); self.remaining_depth.set(old_value + 1); } } } #[cfg(not(feature = "std"))] mod recursion { /// Implementation [`RecursionCounter`] if std is NOT available (and does not /// guard against stack overflow). /// /// Has the same API as the std [`RecursionCounter`] implementation /// but does not actually limit stack depth. pub(crate) struct RecursionCounter {} impl RecursionCounter { pub fn new(_remaining_depth: usize) -> Self { Self {} } pub fn try_decrease(&self) -> Result { Ok(DepthGuard {}) } } pub struct DepthGuard {} } #[derive(PartialEq, Eq)] /// Indicates whether a parser element is optional or mandatory. pub enum IsOptional { /// The element is optional. Optional, /// The element is mandatory. Mandatory, } /// Indicates if a table expression is lateral. pub enum IsLateral { /// The expression is lateral. Lateral, /// The expression is not lateral. NotLateral, } /// Represents a wildcard expression used in SELECT lists. pub enum WildcardExpr { /// A specific expression used instead of a wildcard. Expr(Expr), /// A qualified wildcard like `table.*`. QualifiedWildcard(ObjectName), /// An unqualified `*` wildcard. Wildcard, } impl From for ParserError { fn from(e: TokenizerError) -> Self { ParserError::TokenizerError(e.to_string()) } } impl fmt::Display for ParserError { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "sql parser error: {}", match self { ParserError::TokenizerError(s) => s, ParserError::ParserError(s) => s, ParserError::RecursionLimitExceeded => "recursion limit exceeded", } ) } } impl core::error::Error for ParserError {} // By default, allow expressions up to this deep before erroring const DEFAULT_REMAINING_DEPTH: usize = 50; // A constant EOF token that can be referenced. const EOF_TOKEN: TokenWithSpan = TokenWithSpan { token: Token::EOF, span: Span { start: Location { line: 0, column: 0 }, end: Location { line: 0, column: 0 }, }, }; /// Composite types declarations using angle brackets syntax can be arbitrary /// nested such that the following declaration is possible: /// `ARRAY>` /// But the tokenizer recognizes the `>>` as a ShiftRight token. /// We work around that limitation when parsing a data type by accepting /// either a `>` or `>>` token in such cases, remembering which variant we /// matched. /// In the latter case having matched a `>>`, the parent type will not look to /// match its closing `>` as a result since that will have taken place at the /// child type. /// /// See [Parser::parse_data_type] for details struct MatchedTrailingBracket(bool); impl From for MatchedTrailingBracket { fn from(value: bool) -> Self { Self(value) } } /// Options that control how the [`Parser`] parses SQL text #[derive(Debug, Clone, PartialEq, Eq)] pub struct ParserOptions { /// Allow trailing commas in lists (e.g. `a, b,`). pub trailing_commas: bool, /// Controls how literal values are unescaped. See /// [`Tokenizer::with_unescape`] for more details. pub unescape: bool, /// Controls if the parser expects a semi-colon token /// between statements. Default is `true`. pub require_semicolon_stmt_delimiter: bool, } impl Default for ParserOptions { fn default() -> Self { Self { trailing_commas: false, unescape: true, require_semicolon_stmt_delimiter: true, } } } impl ParserOptions { /// Create a new [`ParserOptions`] pub fn new() -> Self { Default::default() } /// Set if trailing commas are allowed. /// /// If this option is `false` (the default), the following SQL will /// not parse. If the option is `true`, the SQL will parse. /// /// ```sql /// SELECT /// foo, /// bar, /// FROM baz /// ``` pub fn with_trailing_commas(mut self, trailing_commas: bool) -> Self { self.trailing_commas = trailing_commas; self } /// Set if literal values are unescaped. Defaults to true. See /// [`Tokenizer::with_unescape`] for more details. pub fn with_unescape(mut self, unescape: bool) -> Self { self.unescape = unescape; self } } #[derive(Copy, Clone)] enum ParserState { /// The default state of the parser. Normal, /// The state when parsing a CONNECT BY expression. This allows parsing /// PRIOR expressions while still allowing prior as an identifier name /// in other contexts. ConnectBy, /// The state when parsing column definitions. This state prohibits /// NOT NULL as an alias for IS NOT NULL. For example: /// ```sql /// CREATE TABLE foo (abc BIGINT NOT NULL); /// ``` ColumnDefinition, } /// A SQL Parser /// /// This struct is the main entry point for parsing SQL queries. /// /// # Functionality: /// * Parsing SQL: see examples on [`Parser::new`] and [`Parser::parse_sql`] /// * Controlling recursion: See [`Parser::with_recursion_limit`] /// * Controlling parser options: See [`Parser::with_options`] /// * Providing your own tokens: See [`Parser::with_tokens`] /// /// # Internals /// /// The parser uses a [`Tokenizer`] to tokenize the input SQL string into a /// `Vec` of [`TokenWithSpan`]s and maintains an `index` to the current token /// being processed. The token vec may contain multiple SQL statements. /// /// * The "current" token is the token at `index - 1` /// * The "next" token is the token at `index` /// * The "previous" token is the token at `index - 2` /// /// If `index` is equal to the length of the token stream, the 'next' token is /// [`Token::EOF`]. /// /// For example, the SQL string "SELECT * FROM foo" will be tokenized into /// following tokens: /// ```text /// [ /// "SELECT", // token index 0 /// " ", // whitespace /// "*", /// " ", /// "FROM", /// " ", /// "foo" /// ] /// ``` /// /// pub struct Parser<'a> { /// The tokens tokens: Vec, /// The index of the first unprocessed token in [`Parser::tokens`]. index: usize, /// The current state of the parser. state: ParserState, /// The SQL dialect to use. dialect: &'a dyn Dialect, /// Additional options that allow you to mix & match behavior /// otherwise constrained to certain dialects (e.g. trailing /// commas) and/or format of parse (e.g. unescaping). options: ParserOptions, /// Ensures the stack does not overflow by limiting recursion depth. recursion_counter: RecursionCounter, } impl<'a> Parser<'a> { /// Create a parser for a [`Dialect`] /// /// See also [`Parser::parse_sql`] /// /// Example: /// ``` /// # use sqlparser::{parser::{Parser, ParserError}, dialect::GenericDialect}; /// # fn main() -> Result<(), ParserError> { /// let dialect = GenericDialect{}; /// let statements = Parser::new(&dialect) /// .try_with_sql("SELECT * FROM foo")? /// .parse_statements()?; /// # Ok(()) /// # } /// ``` pub fn new(dialect: &'a dyn Dialect) -> Self { Self { tokens: vec![], index: 0, state: ParserState::Normal, dialect, recursion_counter: RecursionCounter::new(DEFAULT_REMAINING_DEPTH), options: ParserOptions::new().with_trailing_commas(dialect.supports_trailing_commas()), } } /// Specify the maximum recursion limit while parsing. /// /// [`Parser`] prevents stack overflows by returning /// [`ParserError::RecursionLimitExceeded`] if the parser exceeds /// this depth while processing the query. /// /// Example: /// ``` /// # use sqlparser::{parser::{Parser, ParserError}, dialect::GenericDialect}; /// # fn main() -> Result<(), ParserError> { /// let dialect = GenericDialect{}; /// let result = Parser::new(&dialect) /// .with_recursion_limit(1) /// .try_with_sql("SELECT * FROM foo WHERE (a OR (b OR (c OR d)))")? /// .parse_statements(); /// assert_eq!(result, Err(ParserError::RecursionLimitExceeded)); /// # Ok(()) /// # } /// ``` /// /// Note: when "recursive-protection" feature is enabled, this crate uses additional stack overflow protection // for some of its recursive methods. See [`recursive::recursive`] for more information. pub fn with_recursion_limit(mut self, recursion_limit: usize) -> Self { self.recursion_counter = RecursionCounter::new(recursion_limit); self } /// Specify additional parser options /// /// [`Parser`] supports additional options ([`ParserOptions`]) /// that allow you to mix & match behavior otherwise constrained /// to certain dialects (e.g. trailing commas). /// /// Example: /// ``` /// # use sqlparser::{parser::{Parser, ParserError, ParserOptions}, dialect::GenericDialect}; /// # fn main() -> Result<(), ParserError> { /// let dialect = GenericDialect{}; /// let options = ParserOptions::new() /// .with_trailing_commas(true) /// .with_unescape(false); /// let result = Parser::new(&dialect) /// .with_options(options) /// .try_with_sql("SELECT a, b, COUNT(*), FROM foo GROUP BY a, b,")? /// .parse_statements(); /// assert!(matches!(result, Ok(_))); /// # Ok(()) /// # } /// ``` pub fn with_options(mut self, options: ParserOptions) -> Self { self.options = options; self } /// Reset this parser to parse the specified token stream pub fn with_tokens_with_locations(mut self, tokens: Vec) -> Self { self.tokens = tokens; self.index = 0; self } /// Reset this parser state to parse the specified tokens pub fn with_tokens(self, tokens: Vec) -> Self { // Put in dummy locations let tokens_with_locations: Vec = tokens .into_iter() .map(|token| TokenWithSpan { token, span: Span::empty(), }) .collect(); self.with_tokens_with_locations(tokens_with_locations) } /// Tokenize the sql string and sets this [`Parser`]'s state to /// parse the resulting tokens /// /// Returns an error if there was an error tokenizing the SQL string. /// /// See example on [`Parser::new()`] for an example pub fn try_with_sql(self, sql: &str) -> Result { debug!("Parsing sql '{sql}'..."); let tokens = Tokenizer::new(self.dialect, sql) .with_unescape(self.options.unescape) .tokenize_with_location()?; Ok(self.with_tokens_with_locations(tokens)) } /// Parse potentially multiple statements /// /// Example /// ``` /// # use sqlparser::{parser::{Parser, ParserError}, dialect::GenericDialect}; /// # fn main() -> Result<(), ParserError> { /// let dialect = GenericDialect{}; /// let statements = Parser::new(&dialect) /// // Parse a SQL string with 2 separate statements /// .try_with_sql("SELECT * FROM foo; SELECT * FROM bar;")? /// .parse_statements()?; /// assert_eq!(statements.len(), 2); /// # Ok(()) /// # } /// ``` pub fn parse_statements(&mut self) -> Result, ParserError> { let mut stmts = Vec::new(); let mut expecting_statement_delimiter = false; loop { // ignore empty statements (between successive statement delimiters) while self.consume_token(&Token::SemiColon) { expecting_statement_delimiter = false; } if !self.options.require_semicolon_stmt_delimiter { expecting_statement_delimiter = false; } match &self.peek_token_ref().token { Token::EOF => break, // end of statement Token::Word(word) if expecting_statement_delimiter && word.keyword == Keyword::END => { break; } _ => {} } if expecting_statement_delimiter { return self.expected_ref("end of statement", self.peek_token_ref()); } let statement = self.parse_statement()?; stmts.push(statement); expecting_statement_delimiter = true; } Ok(stmts) } /// Convenience method to parse a string with one or more SQL /// statements into produce an Abstract Syntax Tree (AST). /// /// Example /// ``` /// # use sqlparser::{parser::{Parser, ParserError}, dialect::GenericDialect}; /// # fn main() -> Result<(), ParserError> { /// let dialect = GenericDialect{}; /// let statements = Parser::parse_sql( /// &dialect, "SELECT * FROM foo" /// )?; /// assert_eq!(statements.len(), 1); /// # Ok(()) /// # } /// ``` pub fn parse_sql(dialect: &dyn Dialect, sql: &str) -> Result, ParserError> { Parser::new(dialect).try_with_sql(sql)?.parse_statements() } /// Parses the given `sql` into an Abstract Syntax Tree (AST), returning /// also encountered source code comments. /// /// See [Parser::parse_sql]. pub fn parse_sql_with_comments( dialect: &'a dyn Dialect, sql: &str, ) -> Result<(Vec, comments::Comments), ParserError> { let mut p = Parser::new(dialect).try_with_sql(sql)?; p.parse_statements().map(|stmts| (stmts, p.into_comments())) } /// Consumes this parser returning comments from the parsed token stream. fn into_comments(self) -> comments::Comments { let mut comments = comments::Comments::default(); for t in self.tokens.into_iter() { match t.token { Token::Whitespace(Whitespace::SingleLineComment { comment, prefix }) => { comments.offer(comments::CommentWithSpan { comment: comments::Comment::SingleLine { content: comment, prefix, }, span: t.span, }); } Token::Whitespace(Whitespace::MultiLineComment(comment)) => { comments.offer(comments::CommentWithSpan { comment: comments::Comment::MultiLine(comment), span: t.span, }); } _ => {} } } comments } /// Parse a single top-level statement (such as SELECT, INSERT, CREATE, etc.), /// stopping before the statement separator, if any. pub fn parse_statement(&mut self) -> Result { let _guard = self.recursion_counter.try_decrease()?; // allow the dialect to override statement parsing if let Some(statement) = self.dialect.parse_statement(self) { return statement; } let next_token = self.next_token(); match &next_token.token { Token::Word(w) => match w.keyword { Keyword::KILL => self.parse_kill(), Keyword::FLUSH => self.parse_flush(), Keyword::DESC => self.parse_explain(DescribeAlias::Desc), Keyword::DESCRIBE => self.parse_explain(DescribeAlias::Describe), Keyword::EXPLAIN => self.parse_explain(DescribeAlias::Explain), Keyword::ANALYZE => self.parse_analyze().map(Into::into), Keyword::CASE => { self.prev_token(); self.parse_case_stmt().map(Into::into) } Keyword::IF => { self.prev_token(); self.parse_if_stmt().map(Into::into) } Keyword::WHILE => { self.prev_token(); self.parse_while().map(Into::into) } Keyword::RAISE => { self.prev_token(); self.parse_raise_stmt().map(Into::into) } Keyword::SELECT | Keyword::WITH | Keyword::VALUES | Keyword::FROM => { self.prev_token(); self.parse_query().map(Into::into) } Keyword::TRUNCATE => self.parse_truncate().map(Into::into), Keyword::ATTACH => { if dialect_of!(self is DuckDbDialect) { self.parse_attach_duckdb_database() } else { self.parse_attach_database() } } Keyword::DETACH if self.dialect.supports_detach() => { self.parse_detach_duckdb_database() } Keyword::MSCK => self.parse_msck().map(Into::into), Keyword::CREATE => self.parse_create(), Keyword::CACHE => self.parse_cache_table(), Keyword::DROP => self.parse_drop(), Keyword::DISCARD => self.parse_discard(), Keyword::DECLARE => self.parse_declare(), Keyword::FETCH => self.parse_fetch_statement(), Keyword::DELETE => self.parse_delete(next_token), Keyword::INSERT => self.parse_insert(next_token), Keyword::REPLACE => self.parse_replace(next_token), Keyword::UNCACHE => self.parse_uncache_table(), Keyword::UPDATE => self.parse_update(next_token), Keyword::ALTER => self.parse_alter(), Keyword::CALL => self.parse_call(), Keyword::COPY => self.parse_copy(), Keyword::OPEN => { self.prev_token(); self.parse_open() } Keyword::CLOSE => self.parse_close(), Keyword::SET => self.parse_set(), Keyword::SHOW => self.parse_show(), Keyword::USE => self.parse_use(), Keyword::GRANT => self.parse_grant().map(Into::into), Keyword::DENY => { self.prev_token(); self.parse_deny() } Keyword::REVOKE => self.parse_revoke().map(Into::into), Keyword::START => self.parse_start_transaction(), Keyword::BEGIN => self.parse_begin(), Keyword::END => self.parse_end(), Keyword::SAVEPOINT => self.parse_savepoint(), Keyword::RELEASE => self.parse_release(), Keyword::COMMIT => self.parse_commit(), Keyword::RAISERROR => Ok(self.parse_raiserror()?), Keyword::THROW => { self.prev_token(); self.parse_throw().map(Into::into) } Keyword::ROLLBACK => self.parse_rollback(), Keyword::ASSERT => self.parse_assert(), // `PREPARE`, `EXECUTE` and `DEALLOCATE` are Postgres-specific // syntaxes. They are used for Postgres prepared statement. Keyword::DEALLOCATE => self.parse_deallocate(), Keyword::EXECUTE | Keyword::EXEC => self.parse_execute(), Keyword::PREPARE => self.parse_prepare(), Keyword::MERGE => self.parse_merge(next_token).map(Into::into), // `LISTEN`, `UNLISTEN` and `NOTIFY` are Postgres-specific // syntaxes. They are used for Postgres statement. Keyword::LISTEN if self.dialect.supports_listen_notify() => self.parse_listen(), Keyword::UNLISTEN if self.dialect.supports_listen_notify() => self.parse_unlisten(), Keyword::NOTIFY if self.dialect.supports_listen_notify() => self.parse_notify(), // `PRAGMA` is sqlite specific https://www.sqlite.org/pragma.html Keyword::PRAGMA => self.parse_pragma(), Keyword::UNLOAD => { self.prev_token(); self.parse_unload() } Keyword::RENAME => self.parse_rename(), // `INSTALL` is duckdb specific https://duckdb.org/docs/extensions/overview Keyword::INSTALL if self.dialect.supports_install() => self.parse_install(), Keyword::LOAD => self.parse_load(), Keyword::LOCK => { self.prev_token(); self.parse_lock_statement().map(Into::into) } Keyword::OPTIMIZE if self.dialect.supports_optimize_table() => { self.parse_optimize_table() } // `COMMENT` is snowflake specific https://docs.snowflake.com/en/sql-reference/sql/comment Keyword::COMMENT if self.dialect.supports_comment_on() => self.parse_comment(), Keyword::PRINT => self.parse_print(), // `WAITFOR` is MSSQL specific https://learn.microsoft.com/en-us/sql/t-sql/language-elements/waitfor-transact-sql Keyword::WAITFOR => self.parse_waitfor(), Keyword::RETURN => self.parse_return(), Keyword::EXPORT => { self.prev_token(); self.parse_export_data() } Keyword::VACUUM => { self.prev_token(); self.parse_vacuum() } Keyword::RESET => self.parse_reset().map(Into::into), _ => self.expected("an SQL statement", next_token), }, Token::LParen => { self.prev_token(); self.parse_query().map(Into::into) } _ => self.expected("an SQL statement", next_token), } } /// Parse a `CASE` statement. /// /// See [Statement::Case] pub fn parse_case_stmt(&mut self) -> Result { let case_token = self.expect_keyword(Keyword::CASE)?; let match_expr = if self.peek_keyword(Keyword::WHEN) { None } else { Some(self.parse_expr()?) }; self.expect_keyword_is(Keyword::WHEN)?; let when_blocks = self.parse_keyword_separated(Keyword::WHEN, |parser| { parser.parse_conditional_statement_block(&[Keyword::WHEN, Keyword::ELSE, Keyword::END]) })?; let else_block = if self.parse_keyword(Keyword::ELSE) { Some(self.parse_conditional_statement_block(&[Keyword::END])?) } else { None }; let mut end_case_token = self.expect_keyword(Keyword::END)?; if self.peek_keyword(Keyword::CASE) { end_case_token = self.expect_keyword(Keyword::CASE)?; } Ok(CaseStatement { case_token: AttachedToken(case_token), match_expr, when_blocks, else_block, end_case_token: AttachedToken(end_case_token), }) } /// Parse an `IF` statement. /// /// See [Statement::If] pub fn parse_if_stmt(&mut self) -> Result { self.expect_keyword_is(Keyword::IF)?; let if_block = self.parse_conditional_statement_block(&[ Keyword::ELSE, Keyword::ELSEIF, Keyword::END, ])?; let elseif_blocks = if self.parse_keyword(Keyword::ELSEIF) { self.parse_keyword_separated(Keyword::ELSEIF, |parser| { parser.parse_conditional_statement_block(&[ Keyword::ELSEIF, Keyword::ELSE, Keyword::END, ]) })? } else { vec![] }; let else_block = if self.parse_keyword(Keyword::ELSE) { Some(self.parse_conditional_statement_block(&[Keyword::END])?) } else { None }; self.expect_keyword_is(Keyword::END)?; let end_token = self.expect_keyword(Keyword::IF)?; Ok(IfStatement { if_block, elseif_blocks, else_block, end_token: Some(AttachedToken(end_token)), }) } /// Parse a `WHILE` statement. /// /// See [Statement::While] fn parse_while(&mut self) -> Result { self.expect_keyword_is(Keyword::WHILE)?; let while_block = self.parse_conditional_statement_block(&[Keyword::END])?; Ok(WhileStatement { while_block }) } /// Parses an expression and associated list of statements /// belonging to a conditional statement like `IF` or `WHEN` or `WHILE`. /// /// Example: /// ```sql /// IF condition THEN statement1; statement2; /// ``` fn parse_conditional_statement_block( &mut self, terminal_keywords: &[Keyword], ) -> Result { let start_token = self.get_current_token().clone(); // self.expect_keyword(keyword)?; let mut then_token = None; let condition = match &start_token.token { Token::Word(w) if w.keyword == Keyword::ELSE => None, Token::Word(w) if w.keyword == Keyword::WHILE => { let expr = self.parse_expr()?; Some(expr) } _ => { let expr = self.parse_expr()?; then_token = Some(AttachedToken(self.expect_keyword(Keyword::THEN)?)); Some(expr) } }; let conditional_statements = self.parse_conditional_statements(terminal_keywords)?; Ok(ConditionalStatementBlock { start_token: AttachedToken(start_token), condition, then_token, conditional_statements, }) } /// Parse a BEGIN/END block or a sequence of statements /// This could be inside of a conditional (IF, CASE, WHILE etc.) or an object body defined optionally BEGIN/END and one or more statements. pub(crate) fn parse_conditional_statements( &mut self, terminal_keywords: &[Keyword], ) -> Result { let conditional_statements = if self.peek_keyword(Keyword::BEGIN) { let begin_token = self.expect_keyword(Keyword::BEGIN)?; let statements = self.parse_statement_list(terminal_keywords)?; let end_token = self.expect_keyword(Keyword::END)?; ConditionalStatements::BeginEnd(BeginEndStatements { begin_token: AttachedToken(begin_token), statements, end_token: AttachedToken(end_token), }) } else { ConditionalStatements::Sequence { statements: self.parse_statement_list(terminal_keywords)?, } }; Ok(conditional_statements) } /// Parse a `RAISE` statement. /// /// See [Statement::Raise] pub fn parse_raise_stmt(&mut self) -> Result { self.expect_keyword_is(Keyword::RAISE)?; let value = if self.parse_keywords(&[Keyword::USING, Keyword::MESSAGE]) { self.expect_token(&Token::Eq)?; Some(RaiseStatementValue::UsingMessage(self.parse_expr()?)) } else { self.maybe_parse(|parser| parser.parse_expr().map(RaiseStatementValue::Expr))? }; Ok(RaiseStatement { value }) } /// Parse a COMMENT statement. /// /// See [Statement::Comment] pub fn parse_comment(&mut self) -> Result { let if_exists = self.parse_keywords(&[Keyword::IF, Keyword::EXISTS]); self.expect_keyword_is(Keyword::ON)?; let token = self.next_token(); let (object_type, object_name) = match token.token { Token::Word(w) if w.keyword == Keyword::COLLATION => { (CommentObject::Collation, self.parse_object_name(false)?) } Token::Word(w) if w.keyword == Keyword::COLUMN => { (CommentObject::Column, self.parse_object_name(false)?) } Token::Word(w) if w.keyword == Keyword::DATABASE => { (CommentObject::Database, self.parse_object_name(false)?) } Token::Word(w) if w.keyword == Keyword::DOMAIN => { (CommentObject::Domain, self.parse_object_name(false)?) } Token::Word(w) if w.keyword == Keyword::EXTENSION => { (CommentObject::Extension, self.parse_object_name(false)?) } Token::Word(w) if w.keyword == Keyword::FUNCTION => { (CommentObject::Function, self.parse_object_name(false)?) } Token::Word(w) if w.keyword == Keyword::INDEX => { (CommentObject::Index, self.parse_object_name(false)?) } Token::Word(w) if w.keyword == Keyword::MATERIALIZED => { self.expect_keyword_is(Keyword::VIEW)?; ( CommentObject::MaterializedView, self.parse_object_name(false)?, ) } Token::Word(w) if w.keyword == Keyword::PROCEDURE => { (CommentObject::Procedure, self.parse_object_name(false)?) } Token::Word(w) if w.keyword == Keyword::ROLE => { (CommentObject::Role, self.parse_object_name(false)?) } Token::Word(w) if w.keyword == Keyword::SCHEMA => { (CommentObject::Schema, self.parse_object_name(false)?) } Token::Word(w) if w.keyword == Keyword::SEQUENCE => { (CommentObject::Sequence, self.parse_object_name(false)?) } Token::Word(w) if w.keyword == Keyword::TABLE => { (CommentObject::Table, self.parse_object_name(false)?) } Token::Word(w) if w.keyword == Keyword::TYPE => { (CommentObject::Type, self.parse_object_name(false)?) } Token::Word(w) if w.keyword == Keyword::USER => { (CommentObject::User, self.parse_object_name(false)?) } Token::Word(w) if w.keyword == Keyword::VIEW => { (CommentObject::View, self.parse_object_name(false)?) } _ => self.expected("comment object_type", token)?, }; self.expect_keyword_is(Keyword::IS)?; let comment = if self.parse_keyword(Keyword::NULL) { None } else { Some(self.parse_literal_string()?) }; Ok(Statement::Comment { object_type, object_name, comment, if_exists, }) } /// Parse `FLUSH` statement. pub fn parse_flush(&mut self) -> Result { let mut channel = None; let mut tables: Vec = vec![]; let mut read_lock = false; let mut export = false; if !dialect_of!(self is MySqlDialect | GenericDialect) { return parser_err!( "Unsupported statement FLUSH", self.peek_token_ref().span.start ); } let location = if self.parse_keyword(Keyword::NO_WRITE_TO_BINLOG) { Some(FlushLocation::NoWriteToBinlog) } else if self.parse_keyword(Keyword::LOCAL) { Some(FlushLocation::Local) } else { None }; let object_type = if self.parse_keywords(&[Keyword::BINARY, Keyword::LOGS]) { FlushType::BinaryLogs } else if self.parse_keywords(&[Keyword::ENGINE, Keyword::LOGS]) { FlushType::EngineLogs } else if self.parse_keywords(&[Keyword::ERROR, Keyword::LOGS]) { FlushType::ErrorLogs } else if self.parse_keywords(&[Keyword::GENERAL, Keyword::LOGS]) { FlushType::GeneralLogs } else if self.parse_keywords(&[Keyword::HOSTS]) { FlushType::Hosts } else if self.parse_keyword(Keyword::PRIVILEGES) { FlushType::Privileges } else if self.parse_keyword(Keyword::OPTIMIZER_COSTS) { FlushType::OptimizerCosts } else if self.parse_keywords(&[Keyword::RELAY, Keyword::LOGS]) { if self.parse_keywords(&[Keyword::FOR, Keyword::CHANNEL]) { channel = Some(self.parse_object_name(false).unwrap().to_string()); } FlushType::RelayLogs } else if self.parse_keywords(&[Keyword::SLOW, Keyword::LOGS]) { FlushType::SlowLogs } else if self.parse_keyword(Keyword::STATUS) { FlushType::Status } else if self.parse_keyword(Keyword::USER_RESOURCES) { FlushType::UserResources } else if self.parse_keywords(&[Keyword::LOGS]) { FlushType::Logs } else if self.parse_keywords(&[Keyword::TABLES]) { loop { let next_token = self.next_token(); match &next_token.token { Token::Word(w) => match w.keyword { Keyword::WITH => { read_lock = self.parse_keywords(&[Keyword::READ, Keyword::LOCK]); } Keyword::FOR => { export = self.parse_keyword(Keyword::EXPORT); } Keyword::NoKeyword => { self.prev_token(); tables = self.parse_comma_separated(|p| p.parse_object_name(false))?; } _ => {} }, _ => { break; } } } FlushType::Tables } else { return self.expected_ref( "BINARY LOGS, ENGINE LOGS, ERROR LOGS, GENERAL LOGS, HOSTS, LOGS, PRIVILEGES, OPTIMIZER_COSTS,\ RELAY LOGS [FOR CHANNEL channel], SLOW LOGS, STATUS, USER_RESOURCES", self.peek_token_ref(), ); }; Ok(Statement::Flush { object_type, location, channel, read_lock, export, tables, }) } /// Parse `MSCK` statement. pub fn parse_msck(&mut self) -> Result { let repair = self.parse_keyword(Keyword::REPAIR); self.expect_keyword_is(Keyword::TABLE)?; let table_name = self.parse_object_name(false)?; let partition_action = self .maybe_parse(|parser| { let pa = match parser.parse_one_of_keywords(&[ Keyword::ADD, Keyword::DROP, Keyword::SYNC, ]) { Some(Keyword::ADD) => Some(AddDropSync::ADD), Some(Keyword::DROP) => Some(AddDropSync::DROP), Some(Keyword::SYNC) => Some(AddDropSync::SYNC), _ => None, }; parser.expect_keyword_is(Keyword::PARTITIONS)?; Ok(pa) })? .unwrap_or_default(); Ok(Msck { repair, table_name, partition_action, }) } /// Parse `TRUNCATE` statement. pub fn parse_truncate(&mut self) -> Result { let table = self.parse_keyword(Keyword::TABLE); let if_exists = self.parse_keywords(&[Keyword::IF, Keyword::EXISTS]); let table_names = self.parse_comma_separated(|p| { let only = p.parse_keyword(Keyword::ONLY); let name = p.parse_object_name(false)?; let has_asterisk = p.consume_token(&Token::Mul); Ok(TruncateTableTarget { name, only, has_asterisk, }) })?; let mut partitions = None; if self.parse_keyword(Keyword::PARTITION) { self.expect_token(&Token::LParen)?; partitions = Some(self.parse_comma_separated(Parser::parse_expr)?); self.expect_token(&Token::RParen)?; } let mut identity = None; let mut cascade = None; if dialect_of!(self is PostgreSqlDialect | GenericDialect) { identity = if self.parse_keywords(&[Keyword::RESTART, Keyword::IDENTITY]) { Some(TruncateIdentityOption::Restart) } else if self.parse_keywords(&[Keyword::CONTINUE, Keyword::IDENTITY]) { Some(TruncateIdentityOption::Continue) } else { None }; cascade = self.parse_cascade_option(); }; let on_cluster = self.parse_optional_on_cluster()?; Ok(Truncate { table_names, partitions, table, if_exists, identity, cascade, on_cluster, }) } fn parse_cascade_option(&mut self) -> Option { if self.parse_keyword(Keyword::CASCADE) { Some(CascadeOption::Cascade) } else if self.parse_keyword(Keyword::RESTRICT) { Some(CascadeOption::Restrict) } else { None } } /// Parse options for `ATTACH DUCKDB DATABASE` statement. pub fn parse_attach_duckdb_database_options( &mut self, ) -> Result, ParserError> { if !self.consume_token(&Token::LParen) { return Ok(vec![]); } let mut options = vec![]; loop { if self.parse_keyword(Keyword::READ_ONLY) { let boolean = if self.parse_keyword(Keyword::TRUE) { Some(true) } else if self.parse_keyword(Keyword::FALSE) { Some(false) } else { None }; options.push(AttachDuckDBDatabaseOption::ReadOnly(boolean)); } else if self.parse_keyword(Keyword::TYPE) { let ident = self.parse_identifier()?; options.push(AttachDuckDBDatabaseOption::Type(ident)); } else { return self .expected_ref("expected one of: ), READ_ONLY, TYPE", self.peek_token_ref()); }; if self.consume_token(&Token::RParen) { return Ok(options); } else if self.consume_token(&Token::Comma) { continue; } else { return self.expected_ref("expected one of: ')', ','", self.peek_token_ref()); } } } /// Parse `ATTACH DUCKDB DATABASE` statement. pub fn parse_attach_duckdb_database(&mut self) -> Result { let database = self.parse_keyword(Keyword::DATABASE); let if_not_exists = self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]); let database_path = self.parse_identifier()?; let database_alias = if self.parse_keyword(Keyword::AS) { Some(self.parse_identifier()?) } else { None }; let attach_options = self.parse_attach_duckdb_database_options()?; Ok(Statement::AttachDuckDBDatabase { if_not_exists, database, database_path, database_alias, attach_options, }) } /// Parse `DETACH DUCKDB DATABASE` statement. pub fn parse_detach_duckdb_database(&mut self) -> Result { let database = self.parse_keyword(Keyword::DATABASE); let if_exists = self.parse_keywords(&[Keyword::IF, Keyword::EXISTS]); let database_alias = self.parse_identifier()?; Ok(Statement::DetachDuckDBDatabase { if_exists, database, database_alias, }) } /// Parse `ATTACH DATABASE` statement. pub fn parse_attach_database(&mut self) -> Result { let database = self.parse_keyword(Keyword::DATABASE); let database_file_name = self.parse_expr()?; self.expect_keyword_is(Keyword::AS)?; let schema_name = self.parse_identifier()?; Ok(Statement::AttachDatabase { database, schema_name, database_file_name, }) } /// Parse `ANALYZE` statement. pub fn parse_analyze(&mut self) -> Result { let has_table_keyword = self.parse_keyword(Keyword::TABLE); let table_name = self.maybe_parse(|parser| parser.parse_object_name(false))?; let mut for_columns = false; let mut cache_metadata = false; let mut noscan = false; let mut partitions = None; let mut compute_statistics = false; let mut columns = vec![]; // PostgreSQL syntax: ANALYZE t (col1, col2) if table_name.is_some() && self.consume_token(&Token::LParen) { columns = self.parse_comma_separated(|p| p.parse_identifier())?; self.expect_token(&Token::RParen)?; } loop { match self.parse_one_of_keywords(&[ Keyword::PARTITION, Keyword::FOR, Keyword::CACHE, Keyword::NOSCAN, Keyword::COMPUTE, ]) { Some(Keyword::PARTITION) => { self.expect_token(&Token::LParen)?; partitions = Some(self.parse_comma_separated(Parser::parse_expr)?); self.expect_token(&Token::RParen)?; } Some(Keyword::NOSCAN) => noscan = true, Some(Keyword::FOR) => { self.expect_keyword_is(Keyword::COLUMNS)?; columns = self .maybe_parse(|parser| { parser.parse_comma_separated(|p| p.parse_identifier()) })? .unwrap_or_default(); for_columns = true } Some(Keyword::CACHE) => { self.expect_keyword_is(Keyword::METADATA)?; cache_metadata = true } Some(Keyword::COMPUTE) => { self.expect_keyword_is(Keyword::STATISTICS)?; compute_statistics = true } _ => break, } } Ok(Analyze { has_table_keyword, table_name, for_columns, columns, partitions, cache_metadata, noscan, compute_statistics, }) } /// Parse a new expression including wildcard & qualified wildcard. pub fn parse_wildcard_expr(&mut self) -> Result { let index = self.index; let next_token = self.next_token(); match next_token.token { t @ (Token::Word(_) | Token::SingleQuotedString(_)) if self.peek_token_ref().token == Token::Period => { let mut id_parts: Vec = vec![match t { Token::Word(w) => w.into_ident(next_token.span), Token::SingleQuotedString(s) => Ident::with_quote('\'', s), _ => { return Err(ParserError::ParserError( "Internal parser error: unexpected token type".to_string(), )) } }]; while self.consume_token(&Token::Period) { let next_token = self.next_token(); match next_token.token { Token::Word(w) => id_parts.push(w.into_ident(next_token.span)), Token::SingleQuotedString(s) => { // SQLite has single-quoted identifiers id_parts.push(Ident::with_quote('\'', s)) } Token::Placeholder(s) => { // Snowflake uses $1, $2, etc. for positional column references // in staged data queries like: SELECT t.$1 FROM @stage t id_parts.push(Ident::new(s)) } Token::Mul => { return Ok(Expr::QualifiedWildcard( ObjectName::from(id_parts), AttachedToken(next_token), )); } _ => { return self.expected("an identifier or a '*' after '.'", next_token); } } } } Token::Mul => { return Ok(Expr::Wildcard(AttachedToken(next_token))); } // Handle parenthesized wildcard: (*) Token::LParen => { let [maybe_mul, maybe_rparen] = self.peek_tokens_ref(); if maybe_mul.token == Token::Mul && maybe_rparen.token == Token::RParen { let mul_token = self.next_token(); // consume Mul self.next_token(); // consume RParen return Ok(Expr::Wildcard(AttachedToken(mul_token))); } } _ => (), }; self.index = index; self.parse_expr() } /// Parse a new expression. pub fn parse_expr(&mut self) -> Result { self.parse_subexpr(self.dialect.prec_unknown()) } /// Parse expression with optional alias and order by. pub fn parse_expr_with_alias_and_order_by( &mut self, ) -> Result { let expr = self.parse_expr()?; fn validator(explicit: bool, kw: &Keyword, _parser: &mut Parser) -> bool { explicit || !&[Keyword::ASC, Keyword::DESC, Keyword::GROUP].contains(kw) } let alias = self.parse_optional_alias_inner(None, validator)?; let order_by = OrderByOptions { asc: self.parse_asc_desc(), nulls_first: None, }; Ok(ExprWithAliasAndOrderBy { expr: ExprWithAlias { expr, alias }, order_by, }) } /// Parse tokens until the precedence changes. #[cfg_attr(feature = "recursive-protection", recursive::recursive)] pub fn parse_subexpr(&mut self, precedence: u8) -> Result { let _guard = self.recursion_counter.try_decrease()?; debug!("parsing expr"); let mut expr = self.parse_prefix()?; expr = self.parse_compound_expr(expr, vec![])?; // Parse an optional collation cast operator following `expr`. // // For example (MSSQL): t1.a COLLATE Latin1_General_CI_AS if !self.in_column_definition_state() && self.parse_keyword(Keyword::COLLATE) { expr = Expr::Collate { expr: Box::new(expr), collation: self.parse_object_name(false)?, }; } debug!("prefix: {expr:?}"); loop { let next_precedence = self.get_next_precedence()?; debug!("next precedence: {next_precedence:?}"); if precedence >= next_precedence { break; } // The period operator is handled exclusively by the // compound field access parsing. if Token::Period == self.peek_token_ref().token { break; } expr = self.parse_infix(expr, next_precedence)?; } Ok(expr) } /// Parse `ASSERT` statement. pub fn parse_assert(&mut self) -> Result { let condition = self.parse_expr()?; let message = if self.parse_keyword(Keyword::AS) { Some(self.parse_expr()?) } else { None }; Ok(Statement::Assert { condition, message }) } /// Parse `SAVEPOINT` statement. pub fn parse_savepoint(&mut self) -> Result { let name = self.parse_identifier()?; Ok(Statement::Savepoint { name }) } /// Parse `RELEASE` statement. pub fn parse_release(&mut self) -> Result { let _ = self.parse_keyword(Keyword::SAVEPOINT); let name = self.parse_identifier()?; Ok(Statement::ReleaseSavepoint { name }) } /// Parse `LISTEN` statement. pub fn parse_listen(&mut self) -> Result { let channel = self.parse_identifier()?; Ok(Statement::LISTEN { channel }) } /// Parse `UNLISTEN` statement. pub fn parse_unlisten(&mut self) -> Result { let channel = if self.consume_token(&Token::Mul) { Ident::new(Expr::Wildcard(AttachedToken::empty()).to_string()) } else { match self.parse_identifier() { Ok(expr) => expr, _ => { self.prev_token(); return self.expected_ref("wildcard or identifier", self.peek_token_ref()); } } }; Ok(Statement::UNLISTEN { channel }) } /// Parse `NOTIFY` statement. pub fn parse_notify(&mut self) -> Result { let channel = self.parse_identifier()?; let payload = if self.consume_token(&Token::Comma) { Some(self.parse_literal_string()?) } else { None }; Ok(Statement::NOTIFY { channel, payload }) } /// Parses a `RENAME TABLE` statement. See [Statement::RenameTable] pub fn parse_rename(&mut self) -> Result { if self.peek_keyword(Keyword::TABLE) { self.expect_keyword(Keyword::TABLE)?; let rename_tables = self.parse_comma_separated(|parser| { let old_name = parser.parse_object_name(false)?; parser.expect_keyword(Keyword::TO)?; let new_name = parser.parse_object_name(false)?; Ok(RenameTable { old_name, new_name }) })?; Ok(rename_tables.into()) } else { self.expected_ref("KEYWORD `TABLE` after RENAME", self.peek_token_ref()) } } /// Tries to parse an expression by matching the specified word to known keywords that have a special meaning in the dialect. /// Returns `None if no match is found. fn parse_expr_prefix_by_reserved_word( &mut self, w: &Word, w_span: Span, ) -> Result, ParserError> { match w.keyword { Keyword::TRUE | Keyword::FALSE if self.dialect.supports_boolean_literals() => { self.prev_token(); Ok(Some(Expr::Value(self.parse_value()?))) } Keyword::NULL => { self.prev_token(); Ok(Some(Expr::Value(self.parse_value()?))) } Keyword::CURRENT_CATALOG | Keyword::CURRENT_USER | Keyword::SESSION_USER | Keyword::USER if dialect_of!(self is PostgreSqlDialect | GenericDialect) => { Ok(Some(Expr::Function(Function { name: ObjectName::from(vec![w.to_ident(w_span)]), uses_odbc_syntax: false, parameters: FunctionArguments::None, args: FunctionArguments::None, null_treatment: None, filter: None, over: None, within_group: vec![], }))) } Keyword::CURRENT_TIMESTAMP | Keyword::CURRENT_TIME | Keyword::CURRENT_DATE | Keyword::LOCALTIME | Keyword::LOCALTIMESTAMP => { Ok(Some(self.parse_time_functions(ObjectName::from(vec![w.to_ident(w_span)]))?)) } Keyword::CASE => Ok(Some(self.parse_case_expr()?)), Keyword::CONVERT => Ok(Some(self.parse_convert_expr(false)?)), Keyword::TRY_CONVERT if self.dialect.supports_try_convert() => Ok(Some(self.parse_convert_expr(true)?)), Keyword::CAST => Ok(Some(self.parse_cast_expr(CastKind::Cast)?)), Keyword::TRY_CAST => Ok(Some(self.parse_cast_expr(CastKind::TryCast)?)), Keyword::SAFE_CAST => Ok(Some(self.parse_cast_expr(CastKind::SafeCast)?)), Keyword::EXISTS // Support parsing Databricks has a function named `exists`. if !dialect_of!(self is DatabricksDialect) || matches!( self.peek_nth_token_ref(1).token, Token::Word(Word { keyword: Keyword::SELECT | Keyword::WITH, .. }) ) => { Ok(Some(self.parse_exists_expr(false)?)) } Keyword::EXTRACT => Ok(Some(self.parse_extract_expr()?)), Keyword::CEIL => Ok(Some(self.parse_ceil_floor_expr(true)?)), Keyword::FLOOR => Ok(Some(self.parse_ceil_floor_expr(false)?)), Keyword::POSITION if self.peek_token_ref().token == Token::LParen => { Ok(Some(self.parse_position_expr(w.to_ident(w_span))?)) } Keyword::SUBSTR | Keyword::SUBSTRING => { self.prev_token(); Ok(Some(self.parse_substring()?)) } Keyword::OVERLAY => Ok(Some(self.parse_overlay_expr()?)), Keyword::TRIM => Ok(Some(self.parse_trim_expr()?)), Keyword::INTERVAL => Ok(Some(self.parse_interval()?)), // Treat ARRAY[1,2,3] as an array [1,2,3], otherwise try as subquery or a function call Keyword::ARRAY if *self.peek_token_ref() == Token::LBracket => { self.expect_token(&Token::LBracket)?; Ok(Some(self.parse_array_expr(true)?)) } Keyword::ARRAY if self.peek_token_ref().token == Token::LParen && !dialect_of!(self is ClickHouseDialect | DatabricksDialect) => { self.expect_token(&Token::LParen)?; let query = self.parse_query()?; self.expect_token(&Token::RParen)?; Ok(Some(Expr::Function(Function { name: ObjectName::from(vec![w.to_ident(w_span)]), uses_odbc_syntax: false, parameters: FunctionArguments::None, args: FunctionArguments::Subquery(query), filter: None, null_treatment: None, over: None, within_group: vec![], }))) } Keyword::NOT => Ok(Some(self.parse_not()?)), Keyword::MATCH if self.dialect.supports_match_against() => { Ok(Some(self.parse_match_against()?)) } Keyword::STRUCT if self.dialect.supports_struct_literal() => { let struct_expr = self.parse_struct_literal()?; Ok(Some(struct_expr)) } Keyword::PRIOR if matches!(self.state, ParserState::ConnectBy) => { let expr = self.parse_subexpr(self.dialect.prec_value(Precedence::PlusMinus))?; Ok(Some(Expr::Prior(Box::new(expr)))) } Keyword::MAP if *self.peek_token_ref() == Token::LBrace && self.dialect.support_map_literal_syntax() => { Ok(Some(self.parse_duckdb_map_literal()?)) } Keyword::LAMBDA if self.dialect.supports_lambda_functions() => { Ok(Some(self.parse_lambda_expr()?)) } _ if self.dialect.supports_geometric_types() => match w.keyword { Keyword::CIRCLE => Ok(Some(self.parse_geometric_type(GeometricTypeKind::Circle)?)), Keyword::BOX => Ok(Some(self.parse_geometric_type(GeometricTypeKind::GeometricBox)?)), Keyword::PATH => Ok(Some(self.parse_geometric_type(GeometricTypeKind::GeometricPath)?)), Keyword::LINE => Ok(Some(self.parse_geometric_type(GeometricTypeKind::Line)?)), Keyword::LSEG => Ok(Some(self.parse_geometric_type(GeometricTypeKind::LineSegment)?)), Keyword::POINT => Ok(Some(self.parse_geometric_type(GeometricTypeKind::Point)?)), Keyword::POLYGON => Ok(Some(self.parse_geometric_type(GeometricTypeKind::Polygon)?)), _ => Ok(None), }, _ => Ok(None), } } /// Tries to parse an expression by a word that is not known to have a special meaning in the dialect. fn parse_expr_prefix_by_unreserved_word( &mut self, w: &Word, w_span: Span, ) -> Result { let is_outer_join = self.peek_outer_join_operator(); match &self.peek_token_ref().token { Token::LParen if !is_outer_join => { let id_parts = vec![w.to_ident(w_span)]; self.parse_function(ObjectName::from(id_parts)) } // string introducer https://dev.mysql.com/doc/refman/8.0/en/charset-introducer.html Token::SingleQuotedString(_) | Token::DoubleQuotedString(_) | Token::HexStringLiteral(_) if w.value.starts_with('_') => { Ok(Expr::Prefixed { prefix: w.to_ident(w_span), value: self.parse_introduced_string_expr()?.into(), }) } // string introducer https://dev.mysql.com/doc/refman/8.0/en/charset-introducer.html Token::SingleQuotedString(_) | Token::DoubleQuotedString(_) | Token::HexStringLiteral(_) if w.value.starts_with('_') => { Ok(Expr::Prefixed { prefix: w.to_ident(w_span), value: self.parse_introduced_string_expr()?.into(), }) } // An unreserved word (likely an identifier) is followed by an arrow, // which indicates a lambda function with a single, untyped parameter. // For example: `a -> a * 2`. Token::Arrow if self.dialect.supports_lambda_functions() => { self.expect_token(&Token::Arrow)?; Ok(Expr::Lambda(LambdaFunction { params: OneOrManyWithParens::One(LambdaFunctionParameter { name: w.to_ident(w_span), data_type: None, }), body: Box::new(self.parse_expr()?), syntax: LambdaSyntax::Arrow, })) } // An unreserved word (likely an identifier) that is followed by another word (likley a data type) // which is then followed by an arrow, which indicates a lambda function with a single, typed parameter. // For example: `a INT -> a * 2`. Token::Word(_) if self.dialect.supports_lambda_functions() && self.peek_nth_token_ref(1).token == Token::Arrow => { let data_type = self.parse_data_type()?; self.expect_token(&Token::Arrow)?; Ok(Expr::Lambda(LambdaFunction { params: OneOrManyWithParens::One(LambdaFunctionParameter { name: w.to_ident(w_span), data_type: Some(data_type), }), body: Box::new(self.parse_expr()?), syntax: LambdaSyntax::Arrow, })) } _ => Ok(Expr::Identifier(w.to_ident(w_span))), } } /// Returns true if the given [ObjectName] is a single unquoted /// identifier matching `expected` (case-insensitive). fn is_simple_unquoted_object_name(name: &ObjectName, expected: &str) -> bool { if let [ObjectNamePart::Identifier(ident)] = name.0.as_slice() { ident.quote_style.is_none() && ident.value.eq_ignore_ascii_case(expected) } else { false } } /// Parse an expression prefix. pub fn parse_prefix(&mut self) -> Result { // allow the dialect to override prefix parsing if let Some(prefix) = self.dialect.parse_prefix(self) { return prefix; } // PostgreSQL allows any string literal to be preceded by a type name, indicating that the // string literal represents a literal of that type. Some examples: // // DATE '2020-05-20' // TIMESTAMP WITH TIME ZONE '2020-05-20 7:43:54' // BOOL 'true' // // The first two are standard SQL, while the latter is a PostgreSQL extension. Complicating // matters is the fact that INTERVAL string literals may optionally be followed by special // keywords, e.g.: // // INTERVAL '7' DAY // // Note also that naively `SELECT date` looks like a syntax error because the `date` type // name is not followed by a string literal, but in fact in PostgreSQL it is a valid // expression that should parse as the column name "date". let loc = self.peek_token_ref().span.start; let opt_expr = self.maybe_parse(|parser| { match parser.parse_data_type()? { DataType::Interval { .. } => parser.parse_interval(), // PostgreSQL allows almost any identifier to be used as custom data type name, // and we support that in `parse_data_type()`. But unlike Postgres we don't // have a list of globally reserved keywords (since they vary across dialects), // so given `NOT 'a' LIKE 'b'`, we'd accept `NOT` as a possible custom data type // name, resulting in `NOT 'a'` being recognized as a `TypedString` instead of // an unary negation `NOT ('a' LIKE 'b')`. To solve this, we don't accept the // `type 'string'` syntax for the custom data types at all ... // // ... with the exception of `xml '...'` on dialects that support XML // expressions, which is a valid PostgreSQL typed string literal. DataType::Custom(ref name, ref modifiers) if modifiers.is_empty() && Self::is_simple_unquoted_object_name(name, "xml") && parser.dialect.supports_xml_expressions() => { Ok(Expr::TypedString(TypedString { data_type: DataType::Custom(name.clone(), modifiers.clone()), value: parser.parse_value()?, uses_odbc_syntax: false, })) } DataType::Custom(..) => parser_err!("dummy", loc), // MySQL supports using the `BINARY` keyword as a cast to binary type. DataType::Binary(..) if self.dialect.supports_binary_kw_as_cast() => { Ok(Expr::Cast { kind: CastKind::Cast, expr: Box::new(parser.parse_expr()?), data_type: DataType::Binary(None), array: false, format: None, }) } data_type => Ok(Expr::TypedString(TypedString { data_type, value: parser.parse_value()?, uses_odbc_syntax: false, })), } })?; if let Some(expr) = opt_expr { return Ok(expr); } // Cache some dialect properties to avoid lifetime issues with the // next_token reference. let dialect = self.dialect; self.advance_token(); let next_token_index = self.get_current_index(); let next_token = self.get_current_token(); let span = next_token.span; let expr = match &next_token.token { Token::Word(w) => { // The word we consumed may fall into one of two cases: it has a special meaning, or not. // For example, in Snowflake, the word `interval` may have two meanings depending on the context: // `SELECT CURRENT_DATE() + INTERVAL '1 DAY', MAX(interval) FROM tbl;` // ^^^^^^^^^^^^^^^^ ^^^^^^^^ // interval expression identifier // // We first try to parse the word and following tokens as a special expression, and if that fails, // we rollback and try to parse it as an identifier. let w = w.clone(); match self.try_parse(|parser| parser.parse_expr_prefix_by_reserved_word(&w, span)) { // This word indicated an expression prefix and parsing was successful Ok(Some(expr)) => Ok(expr), // No expression prefix associated with this word Ok(None) => Ok(self.parse_expr_prefix_by_unreserved_word(&w, span)?), // If parsing of the word as a special expression failed, we are facing two options: // 1. The statement is malformed, e.g. `SELECT INTERVAL '1 DAI` (`DAI` instead of `DAY`) // 2. The word is used as an identifier, e.g. `SELECT MAX(interval) FROM tbl` // We first try to parse the word as an identifier and if that fails // we rollback and return the parsing error we got from trying to parse a // special expression (to maintain backwards compatibility of parsing errors). Err(e) => { if !self.dialect.is_reserved_for_identifier(w.keyword) { if let Ok(Some(expr)) = self.maybe_parse(|parser| { parser.parse_expr_prefix_by_unreserved_word(&w, span) }) { return Ok(expr); } } return Err(e); } } } // End of Token::Word // array `[1, 2, 3]` Token::LBracket => self.parse_array_expr(false), tok @ Token::Minus | tok @ Token::Plus => { let op = if *tok == Token::Plus { UnaryOperator::Plus } else { UnaryOperator::Minus }; Ok(Expr::UnaryOp { op, expr: Box::new( self.parse_subexpr(self.dialect.prec_value(Precedence::MulDivModOp))?, ), }) } Token::ExclamationMark if dialect.supports_bang_not_operator() => Ok(Expr::UnaryOp { op: UnaryOperator::BangNot, expr: Box::new(self.parse_subexpr(self.dialect.prec_value(Precedence::UnaryNot))?), }), tok @ Token::DoubleExclamationMark | tok @ Token::PGSquareRoot | tok @ Token::PGCubeRoot | tok @ Token::AtSign if dialect_is!(dialect is PostgreSqlDialect) => { let op = match tok { Token::DoubleExclamationMark => UnaryOperator::PGPrefixFactorial, Token::PGSquareRoot => UnaryOperator::PGSquareRoot, Token::PGCubeRoot => UnaryOperator::PGCubeRoot, Token::AtSign => UnaryOperator::PGAbs, _ => { return Err(ParserError::ParserError( "Internal parser error: unexpected unary operator token".to_string(), )) } }; Ok(Expr::UnaryOp { op, expr: Box::new( self.parse_subexpr(self.dialect.prec_value(Precedence::PlusMinus))?, ), }) } Token::Tilde => Ok(Expr::UnaryOp { op: UnaryOperator::BitwiseNot, expr: Box::new(self.parse_subexpr(self.dialect.prec_value(Precedence::PlusMinus))?), }), tok @ Token::Sharp | tok @ Token::AtDashAt | tok @ Token::AtAt | tok @ Token::QuestionMarkDash | tok @ Token::QuestionPipe if self.dialect.supports_geometric_types() => { let op = match tok { Token::Sharp => UnaryOperator::Hash, Token::AtDashAt => UnaryOperator::AtDashAt, Token::AtAt => UnaryOperator::DoubleAt, Token::QuestionMarkDash => UnaryOperator::QuestionDash, Token::QuestionPipe => UnaryOperator::QuestionPipe, _ => { return Err(ParserError::ParserError(format!( "Unexpected token in unary operator parsing: {tok:?}" ))) } }; Ok(Expr::UnaryOp { op, expr: Box::new( self.parse_subexpr(self.dialect.prec_value(Precedence::PlusMinus))?, ), }) } Token::EscapedStringLiteral(_) if dialect_is!(dialect is PostgreSqlDialect | GenericDialect) => { self.prev_token(); Ok(Expr::Value(self.parse_value()?)) } Token::UnicodeStringLiteral(_) => { self.prev_token(); Ok(Expr::Value(self.parse_value()?)) } Token::Number(_, _) | Token::SingleQuotedString(_) | Token::DoubleQuotedString(_) | Token::TripleSingleQuotedString(_) | Token::TripleDoubleQuotedString(_) | Token::DollarQuotedString(_) | Token::SingleQuotedByteStringLiteral(_) | Token::DoubleQuotedByteStringLiteral(_) | Token::TripleSingleQuotedByteStringLiteral(_) | Token::TripleDoubleQuotedByteStringLiteral(_) | Token::SingleQuotedRawStringLiteral(_) | Token::DoubleQuotedRawStringLiteral(_) | Token::TripleSingleQuotedRawStringLiteral(_) | Token::TripleDoubleQuotedRawStringLiteral(_) | Token::NationalStringLiteral(_) | Token::QuoteDelimitedStringLiteral(_) | Token::NationalQuoteDelimitedStringLiteral(_) | Token::HexStringLiteral(_) => { self.prev_token(); Ok(Expr::Value(self.parse_value()?)) } Token::LParen => { let expr = if let Some(expr) = self.try_parse_expr_sub_query()? { expr } else if let Some(lambda) = self.try_parse_lambda()? { return Ok(lambda); } else { // Parentheses in expressions switch to "normal" parsing state. // This matters for dialects (SQLite, DuckDB) where `NOT NULL` can // be an alias for `IS NOT NULL`. In column definitions like: // // CREATE TABLE t (c INT DEFAULT (42 NOT NULL) NOT NULL) // // The `(42 NOT NULL)` is an expression with parens, so it parses // as `IsNotNull(42)`. The trailing `NOT NULL` is outside those // expression parens (the outer parens are CREATE TABLE syntax), // so it remains a column constraint. let exprs = self.with_state(ParserState::Normal, |p| { p.parse_comma_separated(Parser::parse_expr) })?; match exprs.len() { 0 => return Err(ParserError::ParserError( "Internal parser error: parse_comma_separated returned empty list" .to_string(), )), 1 => Expr::Nested(Box::new(exprs.into_iter().next().unwrap())), _ => Expr::Tuple(exprs), } }; self.expect_token(&Token::RParen)?; Ok(expr) } Token::Placeholder(_) | Token::Colon | Token::AtSign => { self.prev_token(); Ok(Expr::Value(self.parse_value()?)) } Token::LBrace => { self.prev_token(); self.parse_lbrace_expr() } _ => self.expected_at("an expression", next_token_index), }?; Ok(expr) } fn parse_geometric_type(&mut self, kind: GeometricTypeKind) -> Result { Ok(Expr::TypedString(TypedString { data_type: DataType::GeometricType(kind), value: self.parse_value()?, uses_odbc_syntax: false, })) } /// Try to parse an [Expr::CompoundFieldAccess] like `a.b.c` or `a.b[1].c`. /// If all the fields are `Expr::Identifier`s, return an [Expr::CompoundIdentifier] instead. /// If only the root exists, return the root. /// Parses compound expressions which may be delimited by period /// or bracket notation. /// For example: `a.b.c`, `a.b[1]`. pub fn parse_compound_expr( &mut self, root: Expr, mut chain: Vec, ) -> Result { let mut ending_wildcard: Option = None; loop { if self.consume_token(&Token::Period) { let next_token = self.peek_token_ref(); match &next_token.token { Token::Mul => { // Postgres explicitly allows funcnm(tablenm.*) and the // function array_agg traverses this control flow if dialect_of!(self is PostgreSqlDialect) { ending_wildcard = Some(self.next_token()); } else { // Put back the consumed `.` tokens before exiting. // If this expression is being parsed in the // context of a projection, then the `.*` could imply // a wildcard expansion. For example: // `SELECT STRUCT('foo').* FROM T` self.prev_token(); // . } break; } Token::SingleQuotedString(s) => { let expr = Expr::Identifier(Ident::with_quote_and_span('\'', next_token.span, s)); chain.push(AccessExpr::Dot(expr)); self.advance_token(); // The consumed string } Token::Placeholder(s) => { // Snowflake uses $1, $2, etc. for positional column references // in staged data queries like: SELECT t.$1 FROM @stage t let expr = Expr::Identifier(Ident::with_span(next_token.span, s)); chain.push(AccessExpr::Dot(expr)); self.advance_token(); // The consumed placeholder } // Fallback to parsing an arbitrary expression, but restrict to expression // types that are valid after the dot operator. This ensures that e.g. // `T.interval` is parsed as a compound identifier, not as an interval // expression. _ => { let expr = self.maybe_parse(|parser| { let expr = parser .parse_subexpr(parser.dialect.prec_value(Precedence::Period))?; match &expr { Expr::CompoundFieldAccess { .. } | Expr::CompoundIdentifier(_) | Expr::Identifier(_) | Expr::Value(_) | Expr::Function(_) => Ok(expr), _ => parser.expected_ref( "an identifier or value", parser.peek_token_ref(), ), } })?; match expr { // If we get back a compound field access or identifier, // we flatten the nested expression. // For example if the current root is `foo` // and we get back a compound identifier expression `bar.baz` // The full expression should be `foo.bar.baz` (i.e. // a root with an access chain with 2 entries) and not // `foo.(bar.baz)` (i.e. a root with an access chain with // 1 entry`). Some(Expr::CompoundFieldAccess { root, access_chain }) => { chain.push(AccessExpr::Dot(*root)); chain.extend(access_chain); } Some(Expr::CompoundIdentifier(parts)) => chain.extend( parts.into_iter().map(Expr::Identifier).map(AccessExpr::Dot), ), Some(expr) => { chain.push(AccessExpr::Dot(expr)); } // If the expression is not a valid suffix, fall back to // parsing as an identifier. This handles cases like `T.interval` // where `interval` is a keyword but should be treated as an identifier. None => { chain.push(AccessExpr::Dot(Expr::Identifier( self.parse_identifier()?, ))); } } } } } else if !self.dialect.supports_partiql() && self.peek_token_ref().token == Token::LBracket { self.parse_multi_dim_subscript(&mut chain)?; } else { break; } } let tok_index = self.get_current_index(); if let Some(wildcard_token) = ending_wildcard { if !Self::is_all_ident(&root, &chain) { return self .expected_ref("an identifier or a '*' after '.'", self.peek_token_ref()); }; Ok(Expr::QualifiedWildcard( ObjectName::from(Self::exprs_to_idents(root, chain)?), AttachedToken(wildcard_token), )) } else if self.maybe_parse_outer_join_operator() { if !Self::is_all_ident(&root, &chain) { return self.expected_at("column identifier before (+)", tok_index); }; let expr = if chain.is_empty() { root } else { Expr::CompoundIdentifier(Self::exprs_to_idents(root, chain)?) }; Ok(Expr::OuterJoin(expr.into())) } else { Self::build_compound_expr(root, chain) } } /// Combines a root expression and access chain to form /// a compound expression. Which may be a [Expr::CompoundFieldAccess] /// or other special cased expressions like [Expr::CompoundIdentifier], /// [Expr::OuterJoin]. fn build_compound_expr( root: Expr, mut access_chain: Vec, ) -> Result { if access_chain.is_empty() { return Ok(root); } if Self::is_all_ident(&root, &access_chain) { return Ok(Expr::CompoundIdentifier(Self::exprs_to_idents( root, access_chain, )?)); } // Flatten qualified function calls. // For example, the expression `a.b.c.foo(1,2,3)` should // represent a function called `a.b.c.foo`, rather than // a composite expression. if matches!(root, Expr::Identifier(_)) && matches!( access_chain.last(), Some(AccessExpr::Dot(Expr::Function(_))) ) && access_chain .iter() .rev() .skip(1) // All except the Function .all(|access| matches!(access, AccessExpr::Dot(Expr::Identifier(_)))) { let Some(AccessExpr::Dot(Expr::Function(mut func))) = access_chain.pop() else { return parser_err!("expected function expression", root.span().start); }; let compound_func_name = [root] .into_iter() .chain(access_chain.into_iter().flat_map(|access| match access { AccessExpr::Dot(expr) => Some(expr), _ => None, })) .flat_map(|expr| match expr { Expr::Identifier(ident) => Some(ident), _ => None, }) .map(ObjectNamePart::Identifier) .chain(func.name.0) .collect::>(); func.name = ObjectName(compound_func_name); return Ok(Expr::Function(func)); } // Flatten qualified outer join expressions. // For example, the expression `T.foo(+)` should // represent an outer join on the column name `T.foo` // rather than a composite expression. if access_chain.len() == 1 && matches!( access_chain.last(), Some(AccessExpr::Dot(Expr::OuterJoin(_))) ) { let Some(AccessExpr::Dot(Expr::OuterJoin(inner_expr))) = access_chain.pop() else { return parser_err!("expected (+) expression", root.span().start); }; if !Self::is_all_ident(&root, &[]) { return parser_err!("column identifier before (+)", root.span().start); }; let token_start = root.span().start; let mut idents = Self::exprs_to_idents(root, vec![])?; match *inner_expr { Expr::CompoundIdentifier(suffix) => idents.extend(suffix), Expr::Identifier(suffix) => idents.push(suffix), _ => { return parser_err!("column identifier before (+)", token_start); } } return Ok(Expr::OuterJoin(Expr::CompoundIdentifier(idents).into())); } Ok(Expr::CompoundFieldAccess { root: Box::new(root), access_chain, }) } fn keyword_to_modifier(k: Keyword) -> Option { match k { Keyword::LOCAL => Some(ContextModifier::Local), Keyword::GLOBAL => Some(ContextModifier::Global), Keyword::SESSION => Some(ContextModifier::Session), _ => None, } } /// Check if the root is an identifier and all fields are identifiers. fn is_all_ident(root: &Expr, fields: &[AccessExpr]) -> bool { if !matches!(root, Expr::Identifier(_)) { return false; } fields .iter() .all(|x| matches!(x, AccessExpr::Dot(Expr::Identifier(_)))) } /// Convert a root and a list of fields to a list of identifiers. fn exprs_to_idents(root: Expr, fields: Vec) -> Result, ParserError> { let mut idents = vec![]; if let Expr::Identifier(root) = root { idents.push(root); for x in fields { if let AccessExpr::Dot(Expr::Identifier(ident)) = x { idents.push(ident); } else { return parser_err!( format!("Expected identifier, found: {}", x), x.span().start ); } } Ok(idents) } else { parser_err!( format!("Expected identifier, found: {}", root), root.span().start ) } } /// Returns true if the next tokens indicate the outer join operator `(+)`. fn peek_outer_join_operator(&mut self) -> bool { if !self.dialect.supports_outer_join_operator() { return false; } let [maybe_lparen, maybe_plus, maybe_rparen] = self.peek_tokens_ref(); Token::LParen == maybe_lparen.token && Token::Plus == maybe_plus.token && Token::RParen == maybe_rparen.token } /// If the next tokens indicates the outer join operator `(+)`, consume /// the tokens and return true. fn maybe_parse_outer_join_operator(&mut self) -> bool { self.dialect.supports_outer_join_operator() && self.consume_tokens(&[Token::LParen, Token::Plus, Token::RParen]) } /// Parse utility options in the form of `(option1, option2 arg2, option3 arg3, ...)` pub fn parse_utility_options(&mut self) -> Result, ParserError> { self.expect_token(&Token::LParen)?; let options = self.parse_comma_separated(Self::parse_utility_option)?; self.expect_token(&Token::RParen)?; Ok(options) } fn parse_utility_option(&mut self) -> Result { let name = self.parse_identifier()?; let next_token = self.peek_token_ref(); if next_token == &Token::Comma || next_token == &Token::RParen { return Ok(UtilityOption { name, arg: None }); } let arg = self.parse_expr()?; Ok(UtilityOption { name, arg: Some(arg), }) } fn try_parse_expr_sub_query(&mut self) -> Result, ParserError> { if !self.peek_sub_query() { return Ok(None); } Ok(Some(Expr::Subquery(self.parse_query()?))) } fn try_parse_lambda(&mut self) -> Result, ParserError> { if !self.dialect.supports_lambda_functions() { return Ok(None); } self.maybe_parse(|p| { let params = p.parse_comma_separated(|p| p.parse_lambda_function_parameter())?; p.expect_token(&Token::RParen)?; p.expect_token(&Token::Arrow)?; let expr = p.parse_expr()?; Ok(Expr::Lambda(LambdaFunction { params: OneOrManyWithParens::Many(params), body: Box::new(expr), syntax: LambdaSyntax::Arrow, })) }) } /// Parses a lambda expression following the `LAMBDA` keyword syntax. /// /// Syntax: `LAMBDA : ` /// /// Examples: /// - `LAMBDA x : x + 1` /// - `LAMBDA x, i : x > i` /// /// See fn parse_lambda_expr(&mut self) -> Result { // Parse the parameters: either a single identifier or comma-separated identifiers let params = self.parse_lambda_function_parameters()?; // Expect the colon separator self.expect_token(&Token::Colon)?; // Parse the body expression let body = self.parse_expr()?; Ok(Expr::Lambda(LambdaFunction { params, body: Box::new(body), syntax: LambdaSyntax::LambdaKeyword, })) } /// Parses the parameters of a lambda function with optional typing. fn parse_lambda_function_parameters( &mut self, ) -> Result, ParserError> { // Parse the parameters: either a single identifier or comma-separated identifiers let params = if self.consume_token(&Token::LParen) { // Parenthesized parameters: (x, y) let params = self.parse_comma_separated(|p| p.parse_lambda_function_parameter())?; self.expect_token(&Token::RParen)?; OneOrManyWithParens::Many(params) } else { // Unparenthesized parameters: x or x, y let params = self.parse_comma_separated(|p| p.parse_lambda_function_parameter())?; if params.len() == 1 { OneOrManyWithParens::One(params.into_iter().next().unwrap()) } else { OneOrManyWithParens::Many(params) } }; Ok(params) } /// Parses a single parameter of a lambda function, with optional typing. fn parse_lambda_function_parameter(&mut self) -> Result { let name = self.parse_identifier()?; let data_type = match &self.peek_token_ref().token { Token::Word(_) => self.maybe_parse(|p| p.parse_data_type())?, _ => None, }; Ok(LambdaFunctionParameter { name, data_type }) } /// Tries to parse the body of an [ODBC escaping sequence] /// i.e. without the enclosing braces /// Currently implemented: /// Scalar Function Calls /// Date, Time, and Timestamp Literals /// See fn maybe_parse_odbc_body(&mut self) -> Result, ParserError> { // Attempt 1: Try to parse it as a function. if let Some(expr) = self.maybe_parse_odbc_fn_body()? { return Ok(Some(expr)); } // Attempt 2: Try to parse it as a Date, Time or Timestamp Literal self.maybe_parse_odbc_body_datetime() } /// Tries to parse the body of an [ODBC Date, Time, and Timestamp Literals] call. /// /// ```sql /// {d '2025-07-17'} /// {t '14:12:01'} /// {ts '2025-07-17 14:12:01'} /// ``` /// /// [ODBC Date, Time, and Timestamp Literals]: /// https://learn.microsoft.com/en-us/sql/odbc/reference/develop-app/date-time-and-timestamp-literals?view=sql-server-2017 fn maybe_parse_odbc_body_datetime(&mut self) -> Result, ParserError> { self.maybe_parse(|p| { let token = p.next_token().clone(); let word_string = token.token.to_string(); let data_type = match word_string.as_str() { "t" => DataType::Time(None, TimezoneInfo::None), "d" => DataType::Date, "ts" => DataType::Timestamp(None, TimezoneInfo::None), _ => return p.expected("ODBC datetime keyword (t, d, or ts)", token), }; let value = p.parse_value()?; Ok(Expr::TypedString(TypedString { data_type, value, uses_odbc_syntax: true, })) }) } /// Tries to parse the body of an [ODBC function] call. /// i.e. without the enclosing braces /// /// ```sql /// fn myfunc(1,2,3) /// ``` /// /// [ODBC function]: https://learn.microsoft.com/en-us/sql/odbc/reference/develop-app/scalar-function-calls?view=sql-server-2017 fn maybe_parse_odbc_fn_body(&mut self) -> Result, ParserError> { self.maybe_parse(|p| { p.expect_keyword(Keyword::FN)?; let fn_name = p.parse_object_name(false)?; let mut fn_call = p.parse_function_call(fn_name)?; fn_call.uses_odbc_syntax = true; Ok(Expr::Function(fn_call)) }) } /// Parse a function call expression named by `name` and return it as an `Expr`. pub fn parse_function(&mut self, name: ObjectName) -> Result { self.parse_function_call(name).map(Expr::Function) } fn parse_function_call(&mut self, name: ObjectName) -> Result { self.expect_token(&Token::LParen)?; // Snowflake permits a subquery to be passed as an argument without // an enclosing set of parens if it's the only argument. if self.dialect.supports_subquery_as_function_arg() && self.peek_sub_query() { let subquery = self.parse_query()?; self.expect_token(&Token::RParen)?; return Ok(Function { name, uses_odbc_syntax: false, parameters: FunctionArguments::None, args: FunctionArguments::Subquery(subquery), filter: None, null_treatment: None, over: None, within_group: vec![], }); } let mut args = self.parse_function_argument_list()?; let mut parameters = FunctionArguments::None; // ClickHouse aggregations support parametric functions like `HISTOGRAM(0.5, 0.6)(x, y)` // which (0.5, 0.6) is a parameter to the function. if dialect_of!(self is ClickHouseDialect | GenericDialect) && self.consume_token(&Token::LParen) { parameters = FunctionArguments::List(args); args = self.parse_function_argument_list()?; } let within_group = if self.parse_keywords(&[Keyword::WITHIN, Keyword::GROUP]) { self.expect_token(&Token::LParen)?; self.expect_keywords(&[Keyword::ORDER, Keyword::BY])?; let order_by = self.parse_comma_separated(Parser::parse_order_by_expr)?; self.expect_token(&Token::RParen)?; order_by } else { vec![] }; let filter = if self.dialect.supports_filter_during_aggregation() && self.parse_keyword(Keyword::FILTER) && self.consume_token(&Token::LParen) && self.parse_keyword(Keyword::WHERE) { let filter = Some(Box::new(self.parse_expr()?)); self.expect_token(&Token::RParen)?; filter } else { None }; // Syntax for null treatment shows up either in the args list // or after the function call, but not both. let null_treatment = if args .clauses .iter() .all(|clause| !matches!(clause, FunctionArgumentClause::IgnoreOrRespectNulls(_))) { self.parse_null_treatment()? } else { None }; let over = if self.parse_keyword(Keyword::OVER) { if self.consume_token(&Token::LParen) { let window_spec = self.parse_window_spec()?; Some(WindowType::WindowSpec(window_spec)) } else { Some(WindowType::NamedWindow(self.parse_identifier()?)) } } else { None }; Ok(Function { name, uses_odbc_syntax: false, parameters, args: FunctionArguments::List(args), null_treatment, filter, over, within_group, }) } /// Optionally parses a null treatment clause. fn parse_null_treatment(&mut self) -> Result, ParserError> { match self.parse_one_of_keywords(&[Keyword::RESPECT, Keyword::IGNORE]) { Some(keyword) => { self.expect_keyword_is(Keyword::NULLS)?; Ok(match keyword { Keyword::RESPECT => Some(NullTreatment::RespectNulls), Keyword::IGNORE => Some(NullTreatment::IgnoreNulls), _ => None, }) } None => Ok(None), } } /// Parse time-related function `name` possibly followed by `(...)` arguments. pub fn parse_time_functions(&mut self, name: ObjectName) -> Result { let args = if self.consume_token(&Token::LParen) { FunctionArguments::List(self.parse_function_argument_list()?) } else { FunctionArguments::None }; Ok(Expr::Function(Function { name, uses_odbc_syntax: false, parameters: FunctionArguments::None, args, filter: None, over: None, null_treatment: None, within_group: vec![], })) } /// Parse window frame `UNITS` clause: `ROWS`, `RANGE`, or `GROUPS`. pub fn parse_window_frame_units(&mut self) -> Result { let next_token = self.next_token(); match &next_token.token { Token::Word(w) => match w.keyword { Keyword::ROWS => Ok(WindowFrameUnits::Rows), Keyword::RANGE => Ok(WindowFrameUnits::Range), Keyword::GROUPS => Ok(WindowFrameUnits::Groups), _ => self.expected("ROWS, RANGE, GROUPS", next_token)?, }, _ => self.expected("ROWS, RANGE, GROUPS", next_token), } } /// Parse a `WINDOW` frame definition (units and bounds). pub fn parse_window_frame(&mut self) -> Result { let units = self.parse_window_frame_units()?; let (start_bound, end_bound) = if self.parse_keyword(Keyword::BETWEEN) { let start_bound = self.parse_window_frame_bound()?; self.expect_keyword_is(Keyword::AND)?; let end_bound = Some(self.parse_window_frame_bound()?); (start_bound, end_bound) } else { (self.parse_window_frame_bound()?, None) }; Ok(WindowFrame { units, start_bound, end_bound, }) } /// Parse a window frame bound: `CURRENT ROW` or ` PRECEDING|FOLLOWING`. pub fn parse_window_frame_bound(&mut self) -> Result { if self.parse_keywords(&[Keyword::CURRENT, Keyword::ROW]) { Ok(WindowFrameBound::CurrentRow) } else { let rows = if self.parse_keyword(Keyword::UNBOUNDED) { None } else { Some(Box::new(match &self.peek_token_ref().token { Token::SingleQuotedString(_) => self.parse_interval()?, _ => self.parse_expr()?, })) }; if self.parse_keyword(Keyword::PRECEDING) { Ok(WindowFrameBound::Preceding(rows)) } else if self.parse_keyword(Keyword::FOLLOWING) { Ok(WindowFrameBound::Following(rows)) } else { self.expected_ref("PRECEDING or FOLLOWING", self.peek_token_ref()) } } } /// Parse a group by expr. Group by expr can be one of group sets, roll up, cube, or simple expr. fn parse_group_by_expr(&mut self) -> Result { if self.dialect.supports_group_by_expr() { if self.parse_keywords(&[Keyword::GROUPING, Keyword::SETS]) { self.expect_token(&Token::LParen)?; let result = self.parse_comma_separated(|p| p.parse_tuple(true, true))?; self.expect_token(&Token::RParen)?; Ok(Expr::GroupingSets(result)) } else if self.parse_keyword(Keyword::CUBE) { self.expect_token(&Token::LParen)?; let result = self.parse_comma_separated(|p| p.parse_tuple(true, true))?; self.expect_token(&Token::RParen)?; Ok(Expr::Cube(result)) } else if self.parse_keyword(Keyword::ROLLUP) { self.expect_token(&Token::LParen)?; let result = self.parse_comma_separated(|p| p.parse_tuple(true, true))?; self.expect_token(&Token::RParen)?; Ok(Expr::Rollup(result)) } else if self.consume_tokens(&[Token::LParen, Token::RParen]) { // PostgreSQL allow to use empty tuple as a group by expression, // e.g. `GROUP BY (), name`. Please refer to GROUP BY Clause section in // [PostgreSQL](https://www.postgresql.org/docs/16/sql-select.html) Ok(Expr::Tuple(vec![])) } else { self.parse_expr() } } else { // TODO parse rollup for other dialects self.parse_expr() } } /// Parse a tuple with `(` and `)`. /// If `lift_singleton` is true, then a singleton tuple is lifted to a tuple of length 1, otherwise it will fail. /// If `allow_empty` is true, then an empty tuple is allowed. fn parse_tuple( &mut self, lift_singleton: bool, allow_empty: bool, ) -> Result, ParserError> { if lift_singleton { if self.consume_token(&Token::LParen) { let result = if allow_empty && self.consume_token(&Token::RParen) { vec![] } else { let result = self.parse_comma_separated(Parser::parse_expr)?; self.expect_token(&Token::RParen)?; result }; Ok(result) } else { Ok(vec![self.parse_expr()?]) } } else { self.expect_token(&Token::LParen)?; let result = if allow_empty && self.consume_token(&Token::RParen) { vec![] } else { let result = self.parse_comma_separated(Parser::parse_expr)?; self.expect_token(&Token::RParen)?; result }; Ok(result) } } /// Parse a `CASE` expression and return an [`Expr::Case`]. pub fn parse_case_expr(&mut self) -> Result { let case_token = AttachedToken(self.get_current_token().clone()); let mut operand = None; if !self.parse_keyword(Keyword::WHEN) { operand = Some(Box::new(self.parse_expr()?)); self.expect_keyword_is(Keyword::WHEN)?; } let mut conditions = vec![]; loop { let condition = self.parse_expr()?; self.expect_keyword_is(Keyword::THEN)?; let result = self.parse_expr()?; conditions.push(CaseWhen { condition, result }); if !self.parse_keyword(Keyword::WHEN) { break; } } let else_result = if self.parse_keyword(Keyword::ELSE) { Some(Box::new(self.parse_expr()?)) } else { None }; let end_token = AttachedToken(self.expect_keyword(Keyword::END)?); Ok(Expr::Case { case_token, end_token, operand, conditions, else_result, }) } /// Parse an optional `FORMAT` clause for `CAST` expressions. pub fn parse_optional_cast_format(&mut self) -> Result, ParserError> { if self.parse_keyword(Keyword::FORMAT) { let value = self.parse_value()?; match self.parse_optional_time_zone()? { Some(tz) => Ok(Some(CastFormat::ValueAtTimeZone(value, tz))), None => Ok(Some(CastFormat::Value(value))), } } else { Ok(None) } } /// Parse an optional `AT TIME ZONE` clause. pub fn parse_optional_time_zone(&mut self) -> Result, ParserError> { if self.parse_keywords(&[Keyword::AT, Keyword::TIME, Keyword::ZONE]) { self.parse_value().map(Some) } else { Ok(None) } } /// mssql-like convert function fn parse_mssql_convert(&mut self, is_try: bool) -> Result { self.expect_token(&Token::LParen)?; let data_type = self.parse_data_type()?; self.expect_token(&Token::Comma)?; let expr = self.parse_expr()?; let styles = if self.consume_token(&Token::Comma) { self.parse_comma_separated(Parser::parse_expr)? } else { Default::default() }; self.expect_token(&Token::RParen)?; Ok(Expr::Convert { is_try, expr: Box::new(expr), data_type: Some(data_type), charset: None, target_before_value: true, styles, }) } /// Parse a SQL CONVERT function: /// - `CONVERT('héhé' USING utf8mb4)` (MySQL) /// - `CONVERT('héhé', CHAR CHARACTER SET utf8mb4)` (MySQL) /// - `CONVERT(DECIMAL(10, 5), 42)` (MSSQL) - the type comes first pub fn parse_convert_expr(&mut self, is_try: bool) -> Result { if self.dialect.convert_type_before_value() { return self.parse_mssql_convert(is_try); } self.expect_token(&Token::LParen)?; let expr = self.parse_expr()?; if self.parse_keyword(Keyword::USING) { let charset = self.parse_object_name(false)?; self.expect_token(&Token::RParen)?; return Ok(Expr::Convert { is_try, expr: Box::new(expr), data_type: None, charset: Some(charset), target_before_value: false, styles: vec![], }); } self.expect_token(&Token::Comma)?; let data_type = self.parse_data_type()?; let charset = if self.parse_keywords(&[Keyword::CHARACTER, Keyword::SET]) { Some(self.parse_object_name(false)?) } else { None }; self.expect_token(&Token::RParen)?; Ok(Expr::Convert { is_try, expr: Box::new(expr), data_type: Some(data_type), charset, target_before_value: false, styles: vec![], }) } /// Parse a SQL CAST function e.g. `CAST(expr AS FLOAT)` pub fn parse_cast_expr(&mut self, kind: CastKind) -> Result { self.expect_token(&Token::LParen)?; let expr = self.parse_expr()?; self.expect_keyword_is(Keyword::AS)?; let data_type = self.parse_data_type()?; let array = self.parse_keyword(Keyword::ARRAY); let format = self.parse_optional_cast_format()?; self.expect_token(&Token::RParen)?; Ok(Expr::Cast { kind, expr: Box::new(expr), data_type, array, format, }) } /// Parse a SQL EXISTS expression e.g. `WHERE EXISTS(SELECT ...)`. pub fn parse_exists_expr(&mut self, negated: bool) -> Result { self.expect_token(&Token::LParen)?; let exists_node = Expr::Exists { negated, subquery: self.parse_query()?, }; self.expect_token(&Token::RParen)?; Ok(exists_node) } /// Parse a SQL `EXTRACT` expression e.g. `EXTRACT(YEAR FROM date)`. pub fn parse_extract_expr(&mut self) -> Result { self.expect_token(&Token::LParen)?; let field = self.parse_date_time_field()?; let syntax = if self.parse_keyword(Keyword::FROM) { ExtractSyntax::From } else if self.dialect.supports_extract_comma_syntax() && self.consume_token(&Token::Comma) { ExtractSyntax::Comma } else { return Err(ParserError::ParserError( "Expected 'FROM' or ','".to_string(), )); }; let expr = self.parse_expr()?; self.expect_token(&Token::RParen)?; Ok(Expr::Extract { field, expr: Box::new(expr), syntax, }) } /// Parse a `CEIL` or `FLOOR` expression. pub fn parse_ceil_floor_expr(&mut self, is_ceil: bool) -> Result { self.expect_token(&Token::LParen)?; let expr = self.parse_expr()?; // Parse `CEIL/FLOOR(expr)` let field = if self.parse_keyword(Keyword::TO) { // Parse `CEIL/FLOOR(expr TO DateTimeField)` CeilFloorKind::DateTimeField(self.parse_date_time_field()?) } else if self.consume_token(&Token::Comma) { // Parse `CEIL/FLOOR(expr, scale)` let v = self.parse_value()?; if matches!(v.value, Value::Number(_, _)) { CeilFloorKind::Scale(v) } else { return Err(ParserError::ParserError( "Scale field can only be of number type".to_string(), )); } } else { CeilFloorKind::DateTimeField(DateTimeField::NoDateTime) }; self.expect_token(&Token::RParen)?; if is_ceil { Ok(Expr::Ceil { expr: Box::new(expr), field, }) } else { Ok(Expr::Floor { expr: Box::new(expr), field, }) } } /// Parse a `POSITION` expression. pub fn parse_position_expr(&mut self, ident: Ident) -> Result { let between_prec = self.dialect.prec_value(Precedence::Between); let position_expr = self.maybe_parse(|p| { // PARSE SELECT POSITION('@' in field) p.expect_token(&Token::LParen)?; // Parse the subexpr till the IN keyword let expr = p.parse_subexpr(between_prec)?; p.expect_keyword_is(Keyword::IN)?; let from = p.parse_expr()?; p.expect_token(&Token::RParen)?; Ok(Expr::Position { expr: Box::new(expr), r#in: Box::new(from), }) })?; match position_expr { Some(expr) => Ok(expr), // Snowflake supports `position` as an ordinary function call // without the special `IN` syntax. None => self.parse_function(ObjectName::from(vec![ident])), } } /// Parse `SUBSTRING`/`SUBSTR` expressions: `SUBSTRING(expr FROM start FOR length)` or `SUBSTR(expr, start, length)`. pub fn parse_substring(&mut self) -> Result { let shorthand = match self.expect_one_of_keywords(&[Keyword::SUBSTR, Keyword::SUBSTRING])? { Keyword::SUBSTR => true, Keyword::SUBSTRING => false, _ => { self.prev_token(); return self.expected_ref("SUBSTR or SUBSTRING", self.peek_token_ref()); } }; self.expect_token(&Token::LParen)?; let expr = self.parse_expr()?; let mut from_expr = None; let special = self.consume_token(&Token::Comma); if special || self.parse_keyword(Keyword::FROM) { from_expr = Some(self.parse_expr()?); } let mut to_expr = None; if self.parse_keyword(Keyword::FOR) || self.consume_token(&Token::Comma) { to_expr = Some(self.parse_expr()?); } self.expect_token(&Token::RParen)?; Ok(Expr::Substring { expr: Box::new(expr), substring_from: from_expr.map(Box::new), substring_for: to_expr.map(Box::new), special, shorthand, }) } /// Parse an OVERLAY expression. /// /// See [Expr::Overlay] pub fn parse_overlay_expr(&mut self) -> Result { // PARSE OVERLAY (EXPR PLACING EXPR FROM 1 [FOR 3]) self.expect_token(&Token::LParen)?; let expr = self.parse_expr()?; self.expect_keyword_is(Keyword::PLACING)?; let what_expr = self.parse_expr()?; self.expect_keyword_is(Keyword::FROM)?; let from_expr = self.parse_expr()?; let mut for_expr = None; if self.parse_keyword(Keyword::FOR) { for_expr = Some(self.parse_expr()?); } self.expect_token(&Token::RParen)?; Ok(Expr::Overlay { expr: Box::new(expr), overlay_what: Box::new(what_expr), overlay_from: Box::new(from_expr), overlay_for: for_expr.map(Box::new), }) } /// ```sql /// TRIM ([WHERE] ['text' FROM] 'text') /// TRIM ('text') /// TRIM(, [, characters]) -- PostgreSQL, DuckDB, Snowflake, BigQuery, Generic /// ``` pub fn parse_trim_expr(&mut self) -> Result { self.expect_token(&Token::LParen)?; let mut trim_where = None; if let Token::Word(word) = &self.peek_token_ref().token { if [Keyword::BOTH, Keyword::LEADING, Keyword::TRAILING].contains(&word.keyword) { trim_where = Some(self.parse_trim_where()?); } } let expr = self.parse_expr()?; if self.parse_keyword(Keyword::FROM) { let trim_what = Box::new(expr); let expr = self.parse_expr()?; self.expect_token(&Token::RParen)?; Ok(Expr::Trim { expr: Box::new(expr), trim_where, trim_what: Some(trim_what), trim_characters: None, }) } else if self.dialect.supports_comma_separated_trim() && self.consume_token(&Token::Comma) { let characters = self.parse_comma_separated(Parser::parse_expr)?; self.expect_token(&Token::RParen)?; Ok(Expr::Trim { expr: Box::new(expr), trim_where: None, trim_what: None, trim_characters: Some(characters), }) } else { self.expect_token(&Token::RParen)?; Ok(Expr::Trim { expr: Box::new(expr), trim_where, trim_what: None, trim_characters: None, }) } } /// Parse the `WHERE` field for a `TRIM` expression. /// /// See [TrimWhereField] pub fn parse_trim_where(&mut self) -> Result { let next_token = self.next_token(); match &next_token.token { Token::Word(w) => match w.keyword { Keyword::BOTH => Ok(TrimWhereField::Both), Keyword::LEADING => Ok(TrimWhereField::Leading), Keyword::TRAILING => Ok(TrimWhereField::Trailing), _ => self.expected("trim_where field", next_token)?, }, _ => self.expected("trim_where field", next_token), } } /// Parses an array expression `[ex1, ex2, ..]` /// if `named` is `true`, came from an expression like `ARRAY[ex1, ex2]` pub fn parse_array_expr(&mut self, named: bool) -> Result { let exprs = self.parse_comma_separated0(Parser::parse_expr, Token::RBracket)?; self.expect_token(&Token::RBracket)?; Ok(Expr::Array(Array { elem: exprs, named })) } /// Parse the `ON OVERFLOW` clause for `LISTAGG`. /// /// See [`ListAggOnOverflow`] pub fn parse_listagg_on_overflow(&mut self) -> Result, ParserError> { if self.parse_keywords(&[Keyword::ON, Keyword::OVERFLOW]) { if self.parse_keyword(Keyword::ERROR) { Ok(Some(ListAggOnOverflow::Error)) } else { self.expect_keyword_is(Keyword::TRUNCATE)?; let filler = match &self.peek_token_ref().token { Token::Word(w) if w.keyword == Keyword::WITH || w.keyword == Keyword::WITHOUT => { None } Token::SingleQuotedString(_) | Token::EscapedStringLiteral(_) | Token::UnicodeStringLiteral(_) | Token::NationalStringLiteral(_) | Token::QuoteDelimitedStringLiteral(_) | Token::NationalQuoteDelimitedStringLiteral(_) | Token::HexStringLiteral(_) => Some(Box::new(self.parse_expr()?)), _ => self.expected_ref( "either filler, WITH, or WITHOUT in LISTAGG", self.peek_token_ref(), )?, }; let with_count = self.parse_keyword(Keyword::WITH); if !with_count && !self.parse_keyword(Keyword::WITHOUT) { self.expected_ref("either WITH or WITHOUT in LISTAGG", self.peek_token_ref())?; } self.expect_keyword_is(Keyword::COUNT)?; Ok(Some(ListAggOnOverflow::Truncate { filler, with_count })) } } else { Ok(None) } } /// Parse a date/time field for `EXTRACT`, interval qualifiers, and ceil/floor operations. /// /// `EXTRACT` supports a wider set of date/time fields than interval qualifiers, /// so this function may need to be split in two. /// /// See [`DateTimeField`] pub fn parse_date_time_field(&mut self) -> Result { let next_token = self.next_token(); match &next_token.token { Token::Word(w) => match w.keyword { Keyword::YEAR => Ok(DateTimeField::Year), Keyword::YEARS => Ok(DateTimeField::Years), Keyword::MONTH => Ok(DateTimeField::Month), Keyword::MONTHS => Ok(DateTimeField::Months), Keyword::WEEK => { let week_day = if dialect_of!(self is BigQueryDialect | GenericDialect) && self.consume_token(&Token::LParen) { let week_day = self.parse_identifier()?; self.expect_token(&Token::RParen)?; Some(week_day) } else { None }; Ok(DateTimeField::Week(week_day)) } Keyword::WEEKS => Ok(DateTimeField::Weeks), Keyword::DAY => Ok(DateTimeField::Day), Keyword::DAYOFWEEK => Ok(DateTimeField::DayOfWeek), Keyword::DAYOFYEAR => Ok(DateTimeField::DayOfYear), Keyword::DAYS => Ok(DateTimeField::Days), Keyword::DATE => Ok(DateTimeField::Date), Keyword::DATETIME => Ok(DateTimeField::Datetime), Keyword::HOUR => Ok(DateTimeField::Hour), Keyword::HOURS => Ok(DateTimeField::Hours), Keyword::MINUTE => Ok(DateTimeField::Minute), Keyword::MINUTES => Ok(DateTimeField::Minutes), Keyword::SECOND => Ok(DateTimeField::Second), Keyword::SECONDS => Ok(DateTimeField::Seconds), Keyword::CENTURY => Ok(DateTimeField::Century), Keyword::DECADE => Ok(DateTimeField::Decade), Keyword::DOY => Ok(DateTimeField::Doy), Keyword::DOW => Ok(DateTimeField::Dow), Keyword::EPOCH => Ok(DateTimeField::Epoch), Keyword::ISODOW => Ok(DateTimeField::Isodow), Keyword::ISOYEAR => Ok(DateTimeField::Isoyear), Keyword::ISOWEEK => Ok(DateTimeField::IsoWeek), Keyword::JULIAN => Ok(DateTimeField::Julian), Keyword::MICROSECOND => Ok(DateTimeField::Microsecond), Keyword::MICROSECONDS => Ok(DateTimeField::Microseconds), Keyword::MILLENIUM => Ok(DateTimeField::Millenium), Keyword::MILLENNIUM => Ok(DateTimeField::Millennium), Keyword::MILLISECOND => Ok(DateTimeField::Millisecond), Keyword::MILLISECONDS => Ok(DateTimeField::Milliseconds), Keyword::NANOSECOND => Ok(DateTimeField::Nanosecond), Keyword::NANOSECONDS => Ok(DateTimeField::Nanoseconds), Keyword::QUARTER => Ok(DateTimeField::Quarter), Keyword::TIME => Ok(DateTimeField::Time), Keyword::TIMEZONE => Ok(DateTimeField::Timezone), Keyword::TIMEZONE_ABBR => Ok(DateTimeField::TimezoneAbbr), Keyword::TIMEZONE_HOUR => Ok(DateTimeField::TimezoneHour), Keyword::TIMEZONE_MINUTE => Ok(DateTimeField::TimezoneMinute), Keyword::TIMEZONE_REGION => Ok(DateTimeField::TimezoneRegion), _ if self.dialect.allow_extract_custom() => { self.prev_token(); let custom = self.parse_identifier()?; Ok(DateTimeField::Custom(custom)) } _ => self.expected("date/time field", next_token), }, Token::SingleQuotedString(_) if self.dialect.allow_extract_single_quotes() => { self.prev_token(); let custom = self.parse_identifier()?; Ok(DateTimeField::Custom(custom)) } _ => self.expected("date/time field", next_token), } } /// Parse a `NOT` expression. /// /// Represented in the AST as `Expr::UnaryOp` with `UnaryOperator::Not`. pub fn parse_not(&mut self) -> Result { match &self.peek_token_ref().token { Token::Word(w) => match w.keyword { Keyword::EXISTS => { let negated = true; let _ = self.parse_keyword(Keyword::EXISTS); self.parse_exists_expr(negated) } _ => Ok(Expr::UnaryOp { op: UnaryOperator::Not, expr: Box::new( self.parse_subexpr(self.dialect.prec_value(Precedence::UnaryNot))?, ), }), }, _ => Ok(Expr::UnaryOp { op: UnaryOperator::Not, expr: Box::new(self.parse_subexpr(self.dialect.prec_value(Precedence::UnaryNot))?), }), } } /// Parse expression types that start with a left brace '{'. /// Examples: /// ```sql /// -- Dictionary expr. /// {'key1': 'value1', 'key2': 'value2'} /// /// -- Function call using the ODBC syntax. /// { fn CONCAT('foo', 'bar') } /// ``` fn parse_lbrace_expr(&mut self) -> Result { let token = self.expect_token(&Token::LBrace)?; if let Some(fn_expr) = self.maybe_parse_odbc_body()? { self.expect_token(&Token::RBrace)?; return Ok(fn_expr); } if self.dialect.supports_dictionary_syntax() { self.prev_token(); // Put back the '{' return self.parse_dictionary(); } self.expected("an expression", token) } /// Parses fulltext expressions [`sqlparser::ast::Expr::MatchAgainst`] /// /// # Errors /// This method will raise an error if the column list is empty or with invalid identifiers, /// the match expression is not a literal string, or if the search modifier is not valid. pub fn parse_match_against(&mut self) -> Result { let columns = self.parse_parenthesized_qualified_column_list(Mandatory, false)?; self.expect_keyword_is(Keyword::AGAINST)?; self.expect_token(&Token::LParen)?; // MySQL is too permissive about the value, IMO we can't validate it perfectly on syntax level. let match_value = self.parse_value()?; let in_natural_language_mode_keywords = &[ Keyword::IN, Keyword::NATURAL, Keyword::LANGUAGE, Keyword::MODE, ]; let with_query_expansion_keywords = &[Keyword::WITH, Keyword::QUERY, Keyword::EXPANSION]; let in_boolean_mode_keywords = &[Keyword::IN, Keyword::BOOLEAN, Keyword::MODE]; let opt_search_modifier = if self.parse_keywords(in_natural_language_mode_keywords) { if self.parse_keywords(with_query_expansion_keywords) { Some(SearchModifier::InNaturalLanguageModeWithQueryExpansion) } else { Some(SearchModifier::InNaturalLanguageMode) } } else if self.parse_keywords(in_boolean_mode_keywords) { Some(SearchModifier::InBooleanMode) } else if self.parse_keywords(with_query_expansion_keywords) { Some(SearchModifier::WithQueryExpansion) } else { None }; self.expect_token(&Token::RParen)?; Ok(Expr::MatchAgainst { columns, match_value, opt_search_modifier, }) } /// Parse an `INTERVAL` expression. /// /// Some syntactically valid intervals: /// /// ```sql /// 1. INTERVAL '1' DAY /// 2. INTERVAL '1-1' YEAR TO MONTH /// 3. INTERVAL '1' SECOND /// 4. INTERVAL '1:1:1.1' HOUR (5) TO SECOND (5) /// 5. INTERVAL '1.1' SECOND (2, 2) /// 6. INTERVAL '1:1' HOUR (5) TO MINUTE (5) /// 7. (MySql & BigQuery only): INTERVAL 1 DAY /// ``` /// /// Note that we do not currently attempt to parse the quoted value. pub fn parse_interval(&mut self) -> Result { // The SQL standard allows an optional sign before the value string, but // it is not clear if any implementations support that syntax, so we // don't currently try to parse it. (The sign can instead be included // inside the value string.) // to match the different flavours of INTERVAL syntax, we only allow expressions // if the dialect requires an interval qualifier, // see https://github.com/sqlparser-rs/sqlparser-rs/pull/1398 for more details let value = if self.dialect.require_interval_qualifier() { // parse a whole expression so `INTERVAL 1 + 1 DAY` is valid self.parse_expr()? } else { // parse a prefix expression so `INTERVAL 1 DAY` is valid, but `INTERVAL 1 + 1 DAY` is not // this also means that `INTERVAL '5 days' > INTERVAL '1 day'` treated properly self.parse_prefix()? }; // Following the string literal is a qualifier which indicates the units // of the duration specified in the string literal. // // Note that PostgreSQL allows omitting the qualifier, so we provide // this more general implementation. let leading_field = if self.next_token_is_temporal_unit() { Some(self.parse_date_time_field()?) } else if self.dialect.require_interval_qualifier() { return parser_err!( "INTERVAL requires a unit after the literal value", self.peek_token_ref().span.start ); } else { None }; let (leading_precision, last_field, fsec_precision) = if leading_field == Some(DateTimeField::Second) { // SQL mandates special syntax for `SECOND TO SECOND` literals. // Instead of // `SECOND [()] TO SECOND[()]` // one must use the special format: // `SECOND [( [ , ] )]` let last_field = None; let (leading_precision, fsec_precision) = self.parse_optional_precision_scale()?; (leading_precision, last_field, fsec_precision) } else { let leading_precision = self.parse_optional_precision()?; if self.parse_keyword(Keyword::TO) { let last_field = Some(self.parse_date_time_field()?); let fsec_precision = if last_field == Some(DateTimeField::Second) { self.parse_optional_precision()? } else { None }; (leading_precision, last_field, fsec_precision) } else { (leading_precision, None, None) } }; Ok(Expr::Interval(Interval { value: Box::new(value), leading_field, leading_precision, last_field, fractional_seconds_precision: fsec_precision, })) } /// Peek at the next token and determine if it is a temporal unit /// like `second`. pub fn next_token_is_temporal_unit(&mut self) -> bool { if let Token::Word(word) = &self.peek_token_ref().token { matches!( word.keyword, Keyword::YEAR | Keyword::YEARS | Keyword::MONTH | Keyword::MONTHS | Keyword::WEEK | Keyword::WEEKS | Keyword::DAY | Keyword::DAYS | Keyword::HOUR | Keyword::HOURS | Keyword::MINUTE | Keyword::MINUTES | Keyword::SECOND | Keyword::SECONDS | Keyword::CENTURY | Keyword::DECADE | Keyword::DOW | Keyword::DOY | Keyword::EPOCH | Keyword::ISODOW | Keyword::ISOYEAR | Keyword::JULIAN | Keyword::MICROSECOND | Keyword::MICROSECONDS | Keyword::MILLENIUM | Keyword::MILLENNIUM | Keyword::MILLISECOND | Keyword::MILLISECONDS | Keyword::NANOSECOND | Keyword::NANOSECONDS | Keyword::QUARTER | Keyword::TIMEZONE | Keyword::TIMEZONE_HOUR | Keyword::TIMEZONE_MINUTE ) } else { false } } /// Syntax /// ```sql /// -- typed /// STRUCT<[field_name] field_type, ...>( expr1 [, ... ]) /// -- typeless /// STRUCT( expr1 [AS field_name] [, ... ]) /// ``` fn parse_struct_literal(&mut self) -> Result { // Parse the fields definition if exist `<[field_name] field_type, ...>` self.prev_token(); let (fields, trailing_bracket) = self.parse_struct_type_def(Self::parse_struct_field_def)?; if trailing_bracket.0 { return parser_err!( "unmatched > in STRUCT literal", self.peek_token_ref().span.start ); } // Parse the struct values `(expr1 [, ... ])` self.expect_token(&Token::LParen)?; let values = self .parse_comma_separated(|parser| parser.parse_struct_field_expr(!fields.is_empty()))?; self.expect_token(&Token::RParen)?; Ok(Expr::Struct { values, fields }) } /// Parse an expression value for a struct literal /// Syntax /// ```sql /// expr [AS name] /// ``` /// /// For biquery [1], Parameter typed_syntax is set to true if the expression /// is to be parsed as a field expression declared using typed /// struct syntax [2], and false if using typeless struct syntax [3]. /// /// [1]: https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types#constructing_a_struct /// [2]: https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types#typed_struct_syntax /// [3]: https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types#typeless_struct_syntax fn parse_struct_field_expr(&mut self, typed_syntax: bool) -> Result { let expr = self.parse_expr()?; if self.parse_keyword(Keyword::AS) { if typed_syntax { return parser_err!("Typed syntax does not allow AS", { self.prev_token(); self.peek_token_ref().span.start }); } let field_name = self.parse_identifier()?; Ok(Expr::Named { expr: expr.into(), name: field_name, }) } else { Ok(expr) } } /// Parse a Struct type definition as a sequence of field-value pairs. /// The syntax of the Struct elem differs by dialect so it is customised /// by the `elem_parser` argument. /// /// Syntax /// ```sql /// Hive: /// STRUCT /// /// BigQuery: /// STRUCT<[field_name] field_type> /// ``` fn parse_struct_type_def( &mut self, mut elem_parser: F, ) -> Result<(Vec, MatchedTrailingBracket), ParserError> where F: FnMut(&mut Parser<'a>) -> Result<(StructField, MatchedTrailingBracket), ParserError>, { self.expect_keyword_is(Keyword::STRUCT)?; // Nothing to do if we have no type information. if self.peek_token_ref().token != Token::Lt { return Ok((Default::default(), false.into())); } self.next_token(); let mut field_defs = vec![]; let trailing_bracket = loop { let (def, trailing_bracket) = elem_parser(self)?; field_defs.push(def); // The struct field definition is finished if it occurs `>>` or comma. if trailing_bracket.0 || !self.consume_token(&Token::Comma) { break trailing_bracket; } }; Ok(( field_defs, self.expect_closing_angle_bracket(trailing_bracket)?, )) } /// Duckdb Struct Data Type fn parse_duckdb_struct_type_def(&mut self) -> Result, ParserError> { self.expect_keyword_is(Keyword::STRUCT)?; self.expect_token(&Token::LParen)?; let struct_body = self.parse_comma_separated(|parser| { let field_name = parser.parse_identifier()?; let field_type = parser.parse_data_type()?; Ok(StructField { field_name: Some(field_name), field_type, options: None, }) }); self.expect_token(&Token::RParen)?; struct_body } /// Parse a field definition in a [struct] or [tuple]. /// Syntax: /// /// ```sql /// [field_name] field_type /// field_name: field_type /// ``` /// /// [struct]: https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types#declaring_a_struct_type /// [tuple]: https://clickhouse.com/docs/en/sql-reference/data-types/tuple /// [databricks]: https://docs.databricks.com/en/sql/language-manual/data-types/struct-type.html fn parse_struct_field_def( &mut self, ) -> Result<(StructField, MatchedTrailingBracket), ParserError> { // Look beyond the next item to infer whether both field name // and type are specified. let is_named_field = matches!( (self.peek_nth_token(0).token, self.peek_nth_token(1).token), (Token::Word(_), Token::Word(_)) | (Token::Word(_), Token::Colon) ); let field_name = if is_named_field { let name = self.parse_identifier()?; let _ = self.consume_token(&Token::Colon); Some(name) } else { None }; let (field_type, trailing_bracket) = self.parse_data_type_helper()?; let options = self.maybe_parse_options(Keyword::OPTIONS)?; Ok(( StructField { field_name, field_type, options, }, trailing_bracket, )) } /// DuckDB specific: Parse a Union type definition as a sequence of field-value pairs. /// /// Syntax: /// /// ```sql /// UNION(field_name field_type[,...]) /// ``` /// /// [1]: https://duckdb.org/docs/sql/data_types/union.html fn parse_union_type_def(&mut self) -> Result, ParserError> { self.expect_keyword_is(Keyword::UNION)?; self.expect_token(&Token::LParen)?; let fields = self.parse_comma_separated(|p| { Ok(UnionField { field_name: p.parse_identifier()?, field_type: p.parse_data_type()?, }) })?; self.expect_token(&Token::RParen)?; Ok(fields) } /// DuckDB and ClickHouse specific: Parse a duckdb [dictionary] or a clickhouse [map] setting /// /// Syntax: /// /// ```sql /// {'field_name': expr1[, ... ]} /// ``` /// /// [dictionary]: https://duckdb.org/docs/sql/data_types/struct#creating-structs /// [map]: https://clickhouse.com/docs/operations/settings/settings#additional_table_filters fn parse_dictionary(&mut self) -> Result { self.expect_token(&Token::LBrace)?; let fields = self.parse_comma_separated0(Self::parse_dictionary_field, Token::RBrace)?; self.expect_token(&Token::RBrace)?; Ok(Expr::Dictionary(fields)) } /// Parse a field for a duckdb [dictionary] or a clickhouse [map] setting /// /// Syntax /// /// ```sql /// 'name': expr /// ``` /// /// [dictionary]: https://duckdb.org/docs/sql/data_types/struct#creating-structs /// [map]: https://clickhouse.com/docs/operations/settings/settings#additional_table_filters fn parse_dictionary_field(&mut self) -> Result { let key = self.parse_identifier()?; self.expect_token(&Token::Colon)?; let expr = self.parse_expr()?; Ok(DictionaryField { key, value: Box::new(expr), }) } /// DuckDB specific: Parse a duckdb [map] /// /// Syntax: /// /// ```sql /// Map {key1: value1[, ... ]} /// ``` /// /// [map]: https://duckdb.org/docs/sql/data_types/map.html#creating-maps fn parse_duckdb_map_literal(&mut self) -> Result { self.expect_token(&Token::LBrace)?; let fields = self.parse_comma_separated0(Self::parse_duckdb_map_field, Token::RBrace)?; self.expect_token(&Token::RBrace)?; Ok(Expr::Map(Map { entries: fields })) } /// Parse a field for a duckdb [map] /// /// Syntax /// /// ```sql /// key: value /// ``` /// /// [map]: https://duckdb.org/docs/sql/data_types/map.html#creating-maps fn parse_duckdb_map_field(&mut self) -> Result { // Stop before `:` so it can act as a key/value separator let key = self.parse_subexpr(self.dialect.prec_value(Precedence::Colon))?; self.expect_token(&Token::Colon)?; let value = self.parse_expr()?; Ok(MapEntry { key: Box::new(key), value: Box::new(value), }) } /// Parse clickhouse [map] /// /// Syntax /// /// ```sql /// Map(key_data_type, value_data_type) /// ``` /// /// [map]: https://clickhouse.com/docs/en/sql-reference/data-types/map fn parse_click_house_map_def(&mut self) -> Result<(DataType, DataType), ParserError> { self.expect_keyword_is(Keyword::MAP)?; self.expect_token(&Token::LParen)?; let key_data_type = self.parse_data_type()?; self.expect_token(&Token::Comma)?; let value_data_type = self.parse_data_type()?; self.expect_token(&Token::RParen)?; Ok((key_data_type, value_data_type)) } /// Parse clickhouse [tuple] /// /// Syntax /// /// ```sql /// Tuple([field_name] field_type, ...) /// ``` /// /// [tuple]: https://clickhouse.com/docs/en/sql-reference/data-types/tuple fn parse_click_house_tuple_def(&mut self) -> Result, ParserError> { self.expect_keyword_is(Keyword::TUPLE)?; self.expect_token(&Token::LParen)?; let mut field_defs = vec![]; loop { let (def, _) = self.parse_struct_field_def()?; field_defs.push(def); if !self.consume_token(&Token::Comma) { break; } } self.expect_token(&Token::RParen)?; Ok(field_defs) } /// For nested types that use the angle bracket syntax, this matches either /// `>`, `>>` or nothing depending on which variant is expected (specified by the previously /// matched `trailing_bracket` argument). It returns whether there is a trailing /// left to be matched - (i.e. if '>>' was matched). fn expect_closing_angle_bracket( &mut self, trailing_bracket: MatchedTrailingBracket, ) -> Result { let trailing_bracket = if !trailing_bracket.0 { match &self.peek_token_ref().token { Token::Gt => { self.next_token(); false.into() } Token::ShiftRight => { self.next_token(); true.into() } _ => return self.expected_ref(">", self.peek_token_ref()), } } else { false.into() }; Ok(trailing_bracket) } /// Parse an operator following an expression pub fn parse_infix(&mut self, expr: Expr, precedence: u8) -> Result { // allow the dialect to override infix parsing if let Some(infix) = self.dialect.parse_infix(self, &expr, precedence) { return infix; } let dialect = self.dialect; self.advance_token(); let tok = self.get_current_token(); debug!("infix: {tok:?}"); let tok_index = self.get_current_index(); let span = tok.span; let regular_binary_operator = match &tok.token { Token::Spaceship => Some(BinaryOperator::Spaceship), Token::DoubleEq => Some(BinaryOperator::Eq), Token::Assignment => Some(BinaryOperator::Assignment), Token::Eq => Some(BinaryOperator::Eq), Token::Neq => Some(BinaryOperator::NotEq), Token::Gt => Some(BinaryOperator::Gt), Token::GtEq => Some(BinaryOperator::GtEq), Token::Lt => Some(BinaryOperator::Lt), Token::LtEq => Some(BinaryOperator::LtEq), Token::Plus => Some(BinaryOperator::Plus), Token::Minus => Some(BinaryOperator::Minus), Token::Mul => Some(BinaryOperator::Multiply), Token::Mod => Some(BinaryOperator::Modulo), Token::StringConcat => Some(BinaryOperator::StringConcat), Token::Pipe => Some(BinaryOperator::BitwiseOr), Token::Caret => { // In PostgreSQL, ^ stands for the exponentiation operation, // and # stands for XOR. See https://www.postgresql.org/docs/current/functions-math.html if dialect_is!(dialect is PostgreSqlDialect) { Some(BinaryOperator::PGExp) } else { Some(BinaryOperator::BitwiseXor) } } Token::Ampersand => Some(BinaryOperator::BitwiseAnd), Token::Div => Some(BinaryOperator::Divide), Token::DuckIntDiv if dialect_is!(dialect is DuckDbDialect | GenericDialect) => { Some(BinaryOperator::DuckIntegerDivide) } Token::ShiftLeft if dialect.supports_bitwise_shift_operators() => { Some(BinaryOperator::PGBitwiseShiftLeft) } Token::ShiftRight if dialect.supports_bitwise_shift_operators() => { Some(BinaryOperator::PGBitwiseShiftRight) } Token::Sharp if dialect_is!(dialect is PostgreSqlDialect | RedshiftSqlDialect) => { Some(BinaryOperator::PGBitwiseXor) } Token::Overlap if dialect_is!(dialect is PostgreSqlDialect | RedshiftSqlDialect) => { Some(BinaryOperator::PGOverlap) } Token::Overlap if dialect_is!(dialect is PostgreSqlDialect | GenericDialect) => { Some(BinaryOperator::PGOverlap) } Token::Overlap if dialect.supports_double_ampersand_operator() => { Some(BinaryOperator::And) } Token::CaretAt if dialect_is!(dialect is PostgreSqlDialect | GenericDialect) => { Some(BinaryOperator::PGStartsWith) } Token::Tilde => Some(BinaryOperator::PGRegexMatch), Token::TildeAsterisk => Some(BinaryOperator::PGRegexIMatch), Token::ExclamationMarkTilde => Some(BinaryOperator::PGRegexNotMatch), Token::ExclamationMarkTildeAsterisk => Some(BinaryOperator::PGRegexNotIMatch), Token::DoubleTilde => Some(BinaryOperator::PGLikeMatch), Token::DoubleTildeAsterisk => Some(BinaryOperator::PGILikeMatch), Token::ExclamationMarkDoubleTilde => Some(BinaryOperator::PGNotLikeMatch), Token::ExclamationMarkDoubleTildeAsterisk => Some(BinaryOperator::PGNotILikeMatch), Token::Arrow => Some(BinaryOperator::Arrow), Token::LongArrow => Some(BinaryOperator::LongArrow), Token::HashArrow => Some(BinaryOperator::HashArrow), Token::HashLongArrow => Some(BinaryOperator::HashLongArrow), Token::AtArrow => Some(BinaryOperator::AtArrow), Token::ArrowAt => Some(BinaryOperator::ArrowAt), Token::HashMinus => Some(BinaryOperator::HashMinus), Token::AtQuestion => Some(BinaryOperator::AtQuestion), Token::AtAt => Some(BinaryOperator::AtAt), Token::Question => Some(BinaryOperator::Question), Token::QuestionAnd => Some(BinaryOperator::QuestionAnd), Token::QuestionPipe => Some(BinaryOperator::QuestionPipe), Token::CustomBinaryOperator(s) => Some(BinaryOperator::Custom(s.clone())), Token::DoubleSharp if self.dialect.supports_geometric_types() => { Some(BinaryOperator::DoubleHash) } Token::AmpersandLeftAngleBracket if self.dialect.supports_geometric_types() => { Some(BinaryOperator::AndLt) } Token::AmpersandRightAngleBracket if self.dialect.supports_geometric_types() => { Some(BinaryOperator::AndGt) } Token::QuestionMarkDash if self.dialect.supports_geometric_types() => { Some(BinaryOperator::QuestionDash) } Token::AmpersandLeftAngleBracketVerticalBar if self.dialect.supports_geometric_types() => { Some(BinaryOperator::AndLtPipe) } Token::VerticalBarAmpersandRightAngleBracket if self.dialect.supports_geometric_types() => { Some(BinaryOperator::PipeAndGt) } Token::TwoWayArrow if self.dialect.supports_geometric_types() => { Some(BinaryOperator::LtDashGt) } Token::LeftAngleBracketCaret if self.dialect.supports_geometric_types() => { Some(BinaryOperator::LtCaret) } Token::RightAngleBracketCaret if self.dialect.supports_geometric_types() => { Some(BinaryOperator::GtCaret) } Token::QuestionMarkSharp if self.dialect.supports_geometric_types() => { Some(BinaryOperator::QuestionHash) } Token::QuestionMarkDoubleVerticalBar if self.dialect.supports_geometric_types() => { Some(BinaryOperator::QuestionDoublePipe) } Token::QuestionMarkDashVerticalBar if self.dialect.supports_geometric_types() => { Some(BinaryOperator::QuestionDashPipe) } Token::TildeEqual if self.dialect.supports_geometric_types() => { Some(BinaryOperator::TildeEq) } Token::ShiftLeftVerticalBar if self.dialect.supports_geometric_types() => { Some(BinaryOperator::LtLtPipe) } Token::VerticalBarShiftRight if self.dialect.supports_geometric_types() => { Some(BinaryOperator::PipeGtGt) } Token::AtSign if self.dialect.supports_geometric_types() => Some(BinaryOperator::At), Token::Word(w) => match w.keyword { Keyword::AND => Some(BinaryOperator::And), Keyword::OR => Some(BinaryOperator::Or), Keyword::XOR => Some(BinaryOperator::Xor), Keyword::OVERLAPS => Some(BinaryOperator::Overlaps), Keyword::OPERATOR if dialect_is!(dialect is PostgreSqlDialect | GenericDialect) => { self.expect_token(&Token::LParen)?; // there are special rules for operator names in // postgres so we can not use 'parse_object' // or similar. // See https://www.postgresql.org/docs/current/sql-createoperator.html let mut idents = vec![]; loop { self.advance_token(); idents.push(self.get_current_token().to_string()); if !self.consume_token(&Token::Period) { break; } } self.expect_token(&Token::RParen)?; Some(BinaryOperator::PGCustomBinaryOperator(idents)) } _ => None, }, _ => None, }; let tok = self.token_at(tok_index); if let Some(op) = regular_binary_operator { if let Some(keyword) = self.parse_one_of_keywords(&[Keyword::ANY, Keyword::ALL, Keyword::SOME]) { self.expect_token(&Token::LParen)?; let right = if self.peek_sub_query() { // We have a subquery ahead (SELECT\WITH ...) need to rewind and // use the parenthesis for parsing the subquery as an expression. self.prev_token(); // LParen self.parse_subexpr(precedence)? } else { // Non-subquery expression let right = self.parse_subexpr(precedence)?; self.expect_token(&Token::RParen)?; right }; if !matches!( op, BinaryOperator::Gt | BinaryOperator::Lt | BinaryOperator::GtEq | BinaryOperator::LtEq | BinaryOperator::Eq | BinaryOperator::NotEq | BinaryOperator::PGRegexMatch | BinaryOperator::PGRegexIMatch | BinaryOperator::PGRegexNotMatch | BinaryOperator::PGRegexNotIMatch | BinaryOperator::PGLikeMatch | BinaryOperator::PGILikeMatch | BinaryOperator::PGNotLikeMatch | BinaryOperator::PGNotILikeMatch ) { return parser_err!( format!( "Expected one of [=, >, <, =>, =<, !=, ~, ~*, !~, !~*, ~~, ~~*, !~~, !~~*] as comparison operator, found: {op}" ), span.start ); }; Ok(match keyword { Keyword::ALL => Expr::AllOp { left: Box::new(expr), compare_op: op, right: Box::new(right), }, Keyword::ANY | Keyword::SOME => Expr::AnyOp { left: Box::new(expr), compare_op: op, right: Box::new(right), is_some: keyword == Keyword::SOME, }, unexpected_keyword => return Err(ParserError::ParserError( format!("Internal parser error: expected any of {{ALL, ANY, SOME}}, got {unexpected_keyword:?}"), )), }) } else { Ok(Expr::BinaryOp { left: Box::new(expr), op, right: Box::new(self.parse_subexpr(precedence)?), }) } } else if let Token::Word(w) = &tok.token { match w.keyword { Keyword::IS => { if self.parse_keyword(Keyword::NULL) { Ok(Expr::IsNull(Box::new(expr))) } else if self.parse_keywords(&[Keyword::NOT, Keyword::NULL]) { Ok(Expr::IsNotNull(Box::new(expr))) } else if self.parse_keywords(&[Keyword::TRUE]) { Ok(Expr::IsTrue(Box::new(expr))) } else if self.parse_keywords(&[Keyword::NOT, Keyword::TRUE]) { Ok(Expr::IsNotTrue(Box::new(expr))) } else if self.parse_keywords(&[Keyword::FALSE]) { Ok(Expr::IsFalse(Box::new(expr))) } else if self.parse_keywords(&[Keyword::NOT, Keyword::FALSE]) { Ok(Expr::IsNotFalse(Box::new(expr))) } else if self.parse_keywords(&[Keyword::UNKNOWN]) { Ok(Expr::IsUnknown(Box::new(expr))) } else if self.parse_keywords(&[Keyword::NOT, Keyword::UNKNOWN]) { Ok(Expr::IsNotUnknown(Box::new(expr))) } else if self.parse_keywords(&[Keyword::DISTINCT, Keyword::FROM]) { let expr2 = self.parse_expr()?; Ok(Expr::IsDistinctFrom(Box::new(expr), Box::new(expr2))) } else if self.parse_keywords(&[Keyword::NOT, Keyword::DISTINCT, Keyword::FROM]) { let expr2 = self.parse_expr()?; Ok(Expr::IsNotDistinctFrom(Box::new(expr), Box::new(expr2))) } else if let Ok(is_normalized) = self.parse_unicode_is_normalized(expr) { Ok(is_normalized) } else { self.expected_ref( "[NOT] NULL | TRUE | FALSE | DISTINCT | [form] NORMALIZED FROM after IS", self.peek_token_ref(), ) } } Keyword::AT => { self.expect_keywords(&[Keyword::TIME, Keyword::ZONE])?; Ok(Expr::AtTimeZone { timestamp: Box::new(expr), time_zone: Box::new(self.parse_subexpr(precedence)?), }) } Keyword::NOT | Keyword::IN | Keyword::BETWEEN | Keyword::LIKE | Keyword::ILIKE | Keyword::SIMILAR | Keyword::REGEXP | Keyword::RLIKE => { self.prev_token(); let negated = self.parse_keyword(Keyword::NOT); let regexp = self.parse_keyword(Keyword::REGEXP); let rlike = self.parse_keyword(Keyword::RLIKE); let null = if !self.in_column_definition_state() { self.parse_keyword(Keyword::NULL) } else { false }; if regexp || rlike { Ok(Expr::RLike { negated, expr: Box::new(expr), pattern: Box::new( self.parse_subexpr(self.dialect.prec_value(Precedence::Like))?, ), regexp, }) } else if negated && null { Ok(Expr::IsNotNull(Box::new(expr))) } else if self.parse_keyword(Keyword::IN) { self.parse_in(expr, negated) } else if self.parse_keyword(Keyword::BETWEEN) { self.parse_between(expr, negated) } else if self.parse_keyword(Keyword::LIKE) { Ok(Expr::Like { negated, any: self.parse_keyword(Keyword::ANY), expr: Box::new(expr), pattern: Box::new( self.parse_subexpr(self.dialect.prec_value(Precedence::Like))?, ), escape_char: self.parse_escape_char()?, }) } else if self.parse_keyword(Keyword::ILIKE) { Ok(Expr::ILike { negated, any: self.parse_keyword(Keyword::ANY), expr: Box::new(expr), pattern: Box::new( self.parse_subexpr(self.dialect.prec_value(Precedence::Like))?, ), escape_char: self.parse_escape_char()?, }) } else if self.parse_keywords(&[Keyword::SIMILAR, Keyword::TO]) { Ok(Expr::SimilarTo { negated, expr: Box::new(expr), pattern: Box::new( self.parse_subexpr(self.dialect.prec_value(Precedence::Like))?, ), escape_char: self.parse_escape_char()?, }) } else { self.expected_ref("IN or BETWEEN after NOT", self.peek_token_ref()) } } Keyword::NOTNULL if dialect.supports_notnull_operator() => { Ok(Expr::IsNotNull(Box::new(expr))) } Keyword::MEMBER => { if self.parse_keyword(Keyword::OF) { self.expect_token(&Token::LParen)?; let array = self.parse_expr()?; self.expect_token(&Token::RParen)?; Ok(Expr::MemberOf(MemberOf { value: Box::new(expr), array: Box::new(array), })) } else { self.expected_ref("OF after MEMBER", self.peek_token_ref()) } } // Can only happen if `get_next_precedence` got out of sync with this function _ => parser_err!( format!("No infix parser for token {:?}", tok.token), tok.span.start ), } } else if Token::DoubleColon == *tok { Ok(Expr::Cast { kind: CastKind::DoubleColon, expr: Box::new(expr), data_type: self.parse_data_type()?, array: false, format: None, }) } else if Token::ExclamationMark == *tok && self.dialect.supports_factorial_operator() { Ok(Expr::UnaryOp { op: UnaryOperator::PGPostfixFactorial, expr: Box::new(expr), }) } else if Token::LBracket == *tok && self.dialect.supports_partiql() || (Token::Colon == *tok) { self.prev_token(); self.parse_json_access(expr) } else { // Can only happen if `get_next_precedence` got out of sync with this function parser_err!( format!("No infix parser for token {:?}", tok.token), tok.span.start ) } } /// Parse the `ESCAPE CHAR` portion of `LIKE`, `ILIKE`, and `SIMILAR TO` pub fn parse_escape_char(&mut self) -> Result, ParserError> { if self.parse_keyword(Keyword::ESCAPE) { Ok(Some(self.parse_value()?)) } else { Ok(None) } } /// Parses an array subscript like /// * `[:]` /// * `[l]` /// * `[l:]` /// * `[:u]` /// * `[l:u]` /// * `[l:u:s]` /// /// Parser is right after `[` fn parse_subscript_inner(&mut self) -> Result { // at either `:(rest)` or `:(rest)]` let lower_bound = if self.consume_token(&Token::Colon) { None } else { // parse expr until we hit a colon (or any token with lower precedence) Some(self.parse_subexpr(self.dialect.prec_value(Precedence::Colon))?) }; // check for end if self.consume_token(&Token::RBracket) { if let Some(lower_bound) = lower_bound { return Ok(Subscript::Index { index: lower_bound }); }; return Ok(Subscript::Slice { lower_bound, upper_bound: None, stride: None, }); } // consume the `:` if lower_bound.is_some() { self.expect_token(&Token::Colon)?; } // we are now at either `]`, `(rest)]` let upper_bound = if self.consume_token(&Token::RBracket) { return Ok(Subscript::Slice { lower_bound, upper_bound: None, stride: None, }); } else { // parse expr until we hit a colon (or any token with lower precedence) Some(self.parse_subexpr(self.dialect.prec_value(Precedence::Colon))?) }; // check for end if self.consume_token(&Token::RBracket) { return Ok(Subscript::Slice { lower_bound, upper_bound, stride: None, }); } // we are now at `:]` or `:stride]` self.expect_token(&Token::Colon)?; let stride = if self.consume_token(&Token::RBracket) { None } else { Some(self.parse_expr()?) }; if stride.is_some() { self.expect_token(&Token::RBracket)?; } Ok(Subscript::Slice { lower_bound, upper_bound, stride, }) } /// Parse a multi-dimension array accessing like `[1:3][1][1]` pub fn parse_multi_dim_subscript( &mut self, chain: &mut Vec, ) -> Result<(), ParserError> { while self.consume_token(&Token::LBracket) { self.parse_subscript(chain)?; } Ok(()) } /// Parses an array subscript like `[1:3]` /// /// Parser is right after `[` fn parse_subscript(&mut self, chain: &mut Vec) -> Result<(), ParserError> { let subscript = self.parse_subscript_inner()?; chain.push(AccessExpr::Subscript(subscript)); Ok(()) } fn parse_json_path_object_key(&mut self) -> Result { let token = self.next_token(); match token.token { Token::Word(Word { value, // path segments in SF dot notation can be unquoted or double-quoted; // Databricks also supports backtick-quoted identifiers quote_style: quote_style @ (Some('"') | Some('`') | None), // some experimentation suggests that snowflake permits // any keyword here unquoted. keyword: _, }) => Ok(JsonPathElem::Dot { key: value, quoted: quote_style.is_some(), }), // This token should never be generated on snowflake or generic // dialects, but we handle it just in case this is used on future // dialects. Token::DoubleQuotedString(key) => Ok(JsonPathElem::Dot { key, quoted: true }), _ => self.expected("variant object key name", token), } } fn parse_json_access(&mut self, expr: Expr) -> Result { let path = self.parse_json_path()?; Ok(Expr::JsonAccess { value: Box::new(expr), path, }) } fn parse_json_path(&mut self) -> Result { let mut path = Vec::new(); loop { match self.next_token().token { Token::Colon if path.is_empty() && self.peek_token_ref() == &Token::LBracket => { self.next_token(); let key = self.parse_wildcard_expr()?; self.expect_token(&Token::RBracket)?; path.push(JsonPathElem::ColonBracket { key }); } Token::Colon if path.is_empty() => { path.push(self.parse_json_path_object_key()?); } Token::Period if !path.is_empty() => { path.push(self.parse_json_path_object_key()?); } Token::LBracket => { let key = self.parse_wildcard_expr()?; self.expect_token(&Token::RBracket)?; path.push(JsonPathElem::Bracket { key }); } _ => { self.prev_token(); break; } }; } debug_assert!(!path.is_empty()); Ok(JsonPath { path }) } /// Parses the parens following the `[ NOT ] IN` operator. pub fn parse_in(&mut self, expr: Expr, negated: bool) -> Result { // BigQuery allows `IN UNNEST(array_expression)` // https://cloud.google.com/bigquery/docs/reference/standard-sql/operators#in_operators if self.parse_keyword(Keyword::UNNEST) { self.expect_token(&Token::LParen)?; let array_expr = self.parse_expr()?; self.expect_token(&Token::RParen)?; return Ok(Expr::InUnnest { expr: Box::new(expr), array_expr: Box::new(array_expr), negated, }); } self.expect_token(&Token::LParen)?; let in_op = match self.maybe_parse(|p| p.parse_query())? { Some(subquery) => Expr::InSubquery { expr: Box::new(expr), subquery, negated, }, None => Expr::InList { expr: Box::new(expr), list: if self.dialect.supports_in_empty_list() { self.parse_comma_separated0(Parser::parse_expr, Token::RParen)? } else { self.parse_comma_separated(Parser::parse_expr)? }, negated, }, }; self.expect_token(&Token::RParen)?; Ok(in_op) } /// Parses `BETWEEN AND `, assuming the `BETWEEN` keyword was already consumed. pub fn parse_between(&mut self, expr: Expr, negated: bool) -> Result { // Stop parsing subexpressions for and on tokens with // precedence lower than that of `BETWEEN`, such as `AND`, `IS`, etc. let low = self.parse_subexpr(self.dialect.prec_value(Precedence::Between))?; self.expect_keyword_is(Keyword::AND)?; let high = self.parse_subexpr(self.dialect.prec_value(Precedence::Between))?; Ok(Expr::Between { expr: Box::new(expr), negated, low: Box::new(low), high: Box::new(high), }) } /// Parse a PostgreSQL casting style which is in the form of `expr::datatype`. pub fn parse_pg_cast(&mut self, expr: Expr) -> Result { Ok(Expr::Cast { kind: CastKind::DoubleColon, expr: Box::new(expr), data_type: self.parse_data_type()?, array: false, format: None, }) } /// Get the precedence of the next token pub fn get_next_precedence(&self) -> Result { self.dialect.get_next_precedence_default(self) } /// Return the token at the given location, or EOF if the index is beyond /// the length of the current set of tokens. pub fn token_at(&self, index: usize) -> &TokenWithSpan { self.tokens.get(index).unwrap_or(&EOF_TOKEN) } /// Return the first non-whitespace token that has not yet been processed /// or Token::EOF /// /// See [`Self::peek_token_ref`] to avoid the copy. pub fn peek_token(&self) -> TokenWithSpan { self.peek_nth_token(0) } /// Return a reference to the first non-whitespace token that has not yet /// been processed or Token::EOF pub fn peek_token_ref(&self) -> &TokenWithSpan { self.peek_nth_token_ref(0) } /// Returns the `N` next non-whitespace tokens that have not yet been /// processed. /// /// Example: /// ```rust /// # use sqlparser::dialect::GenericDialect; /// # use sqlparser::parser::Parser; /// # use sqlparser::keywords::Keyword; /// # use sqlparser::tokenizer::{Token, Word}; /// let dialect = GenericDialect {}; /// let mut parser = Parser::new(&dialect).try_with_sql("ORDER BY foo, bar").unwrap(); /// /// // Note that Rust infers the number of tokens to peek based on the /// // length of the slice pattern! /// assert!(matches!( /// parser.peek_tokens(), /// [ /// Token::Word(Word { keyword: Keyword::ORDER, .. }), /// Token::Word(Word { keyword: Keyword::BY, .. }), /// ] /// )); /// ``` pub fn peek_tokens(&self) -> [Token; N] { self.peek_tokens_with_location() .map(|with_loc| with_loc.token) } /// Returns the `N` next non-whitespace tokens with locations that have not /// yet been processed. /// /// See [`Self::peek_token`] for an example. pub fn peek_tokens_with_location(&self) -> [TokenWithSpan; N] { let mut index = self.index; core::array::from_fn(|_| loop { let token = self.tokens.get(index); index += 1; if let Some(TokenWithSpan { token: Token::Whitespace(_), span: _, }) = token { continue; } break token.cloned().unwrap_or(TokenWithSpan { token: Token::EOF, span: Span::empty(), }); }) } /// Returns references to the `N` next non-whitespace tokens /// that have not yet been processed. /// /// See [`Self::peek_tokens`] for an example. pub fn peek_tokens_ref(&self) -> [&TokenWithSpan; N] { let mut index = self.index; core::array::from_fn(|_| loop { let token = self.tokens.get(index); index += 1; if let Some(TokenWithSpan { token: Token::Whitespace(_), span: _, }) = token { continue; } break token.unwrap_or(&EOF_TOKEN); }) } /// Return nth non-whitespace token that has not yet been processed pub fn peek_nth_token(&self, n: usize) -> TokenWithSpan { self.peek_nth_token_ref(n).clone() } /// Return nth non-whitespace token that has not yet been processed pub fn peek_nth_token_ref(&self, mut n: usize) -> &TokenWithSpan { let mut index = self.index; loop { index += 1; match self.tokens.get(index - 1) { Some(TokenWithSpan { token: Token::Whitespace(_), span: _, }) => continue, non_whitespace => { if n == 0 { return non_whitespace.unwrap_or(&EOF_TOKEN); } n -= 1; } } } } /// Return the first token, possibly whitespace, that has not yet been processed /// (or None if reached end-of-file). pub fn peek_token_no_skip(&self) -> TokenWithSpan { self.peek_nth_token_no_skip(0) } /// Return nth token, possibly whitespace, that has not yet been processed. pub fn peek_nth_token_no_skip(&self, n: usize) -> TokenWithSpan { self.tokens .get(self.index + n) .cloned() .unwrap_or(TokenWithSpan { token: Token::EOF, span: Span::empty(), }) } /// Return nth token, possibly whitespace, that has not yet been processed. fn peek_nth_token_no_skip_ref(&self, n: usize) -> &TokenWithSpan { self.tokens.get(self.index + n).unwrap_or(&EOF_TOKEN) } /// Return true if the next tokens exactly `expected` /// /// Does not advance the current token. fn peek_keywords(&mut self, expected: &[Keyword]) -> bool { let index = self.index; let matched = self.parse_keywords(expected); self.index = index; matched } /// Advances to the next non-whitespace token and returns a copy. /// /// Please use [`Self::advance_token`] and [`Self::get_current_token`] to /// avoid the copy. pub fn next_token(&mut self) -> TokenWithSpan { self.advance_token(); self.get_current_token().clone() } /// Returns the index of the current token /// /// This can be used with APIs that expect an index, such as /// [`Self::token_at`] pub fn get_current_index(&self) -> usize { self.index.saturating_sub(1) } /// Return the next unprocessed token, possibly whitespace. pub fn next_token_no_skip(&mut self) -> Option<&TokenWithSpan> { self.index += 1; self.tokens.get(self.index - 1) } /// Advances the current token to the next non-whitespace token /// /// See [`Self::get_current_token`] to get the current token after advancing pub fn advance_token(&mut self) { loop { self.index += 1; match self.tokens.get(self.index - 1) { Some(TokenWithSpan { token: Token::Whitespace(_), span: _, }) => continue, _ => break, } } } /// Returns a reference to the current token /// /// Does not advance the current token. pub fn get_current_token(&self) -> &TokenWithSpan { self.token_at(self.index.saturating_sub(1)) } /// Returns a reference to the previous token /// /// Does not advance the current token. pub fn get_previous_token(&self) -> &TokenWithSpan { self.token_at(self.index.saturating_sub(2)) } /// Returns a reference to the next token /// /// Does not advance the current token. pub fn get_next_token(&self) -> &TokenWithSpan { self.token_at(self.index) } /// Seek back the last one non-whitespace token. /// /// Must be called after `next_token()`, otherwise might panic. OK to call /// after `next_token()` indicates an EOF. /// // TODO rename to backup_token and deprecate prev_token? pub fn prev_token(&mut self) { loop { assert!(self.index > 0); self.index -= 1; if let Some(TokenWithSpan { token: Token::Whitespace(_), span: _, }) = self.tokens.get(self.index) { continue; } return; } } /// Report `found` was encountered instead of `expected` pub fn expected(&self, expected: &str, found: TokenWithSpan) -> Result { parser_err!( format!("Expected: {expected}, found: {found}"), found.span.start ) } /// report `found` was encountered instead of `expected` pub fn expected_ref(&self, expected: &str, found: &TokenWithSpan) -> Result { parser_err!( format!("Expected: {expected}, found: {found}"), found.span.start ) } /// Report that the token at `index` was found instead of `expected`. pub fn expected_at(&self, expected: &str, index: usize) -> Result { let found = self.tokens.get(index).unwrap_or(&EOF_TOKEN); parser_err!( format!("Expected: {expected}, found: {found}"), found.span.start ) } /// If the current token is the `expected` keyword, consume it and returns /// true. Otherwise, no tokens are consumed and returns false. #[must_use] pub fn parse_keyword(&mut self, expected: Keyword) -> bool { if self.peek_keyword(expected) { self.advance_token(); true } else { false } } #[must_use] /// Check if the current token is the expected keyword without consuming it. /// /// Returns true if the current token matches the expected keyword. pub fn peek_keyword(&self, expected: Keyword) -> bool { matches!(&self.peek_token_ref().token, Token::Word(w) if expected == w.keyword) } /// If the current token is the `expected` keyword followed by /// specified tokens, consume them and returns true. /// Otherwise, no tokens are consumed and returns false. /// /// Note that if the length of `tokens` is too long, this function will /// not be efficient as it does a loop on the tokens with `peek_nth_token` /// each time. pub fn parse_keyword_with_tokens(&mut self, expected: Keyword, tokens: &[Token]) -> bool { self.keyword_with_tokens(expected, tokens, true) } /// Peeks to see if the current token is the `expected` keyword followed by specified tokens /// without consuming them. /// /// See [Self::parse_keyword_with_tokens] for details. pub(crate) fn peek_keyword_with_tokens(&mut self, expected: Keyword, tokens: &[Token]) -> bool { self.keyword_with_tokens(expected, tokens, false) } fn keyword_with_tokens(&mut self, expected: Keyword, tokens: &[Token], consume: bool) -> bool { match &self.peek_token_ref().token { Token::Word(w) if expected == w.keyword => { for (idx, token) in tokens.iter().enumerate() { if self.peek_nth_token_ref(idx + 1).token != *token { return false; } } if consume { for _ in 0..(tokens.len() + 1) { self.advance_token(); } } true } _ => false, } } /// If the current and subsequent tokens exactly match the `keywords` /// sequence, consume them and returns true. Otherwise, no tokens are /// consumed and returns false #[must_use] pub fn parse_keywords(&mut self, keywords: &[Keyword]) -> bool { self.parse_keywords_indexed(keywords).is_some() } /// Just like [Self::parse_keywords], but - upon success - returns the /// token index of the first keyword. #[must_use] fn parse_keywords_indexed(&mut self, keywords: &[Keyword]) -> Option { let start_index = self.index; let mut first_keyword_index = None; for &keyword in keywords { if !self.parse_keyword(keyword) { self.index = start_index; return None; } if first_keyword_index.is_none() { first_keyword_index = Some(self.index.saturating_sub(1)); } } first_keyword_index } /// If the current token is one of the given `keywords`, returns the keyword /// that matches, without consuming the token. Otherwise, returns [`None`]. #[must_use] pub fn peek_one_of_keywords(&self, keywords: &[Keyword]) -> Option { for keyword in keywords { if self.peek_keyword(*keyword) { return Some(*keyword); } } None } /// If the current token is one of the given `keywords`, consume the token /// and return the keyword that matches. Otherwise, no tokens are consumed /// and returns [`None`]. #[must_use] pub fn parse_one_of_keywords(&mut self, keywords: &[Keyword]) -> Option { match &self.peek_token_ref().token { Token::Word(w) => { keywords .iter() .find(|keyword| **keyword == w.keyword) .map(|keyword| { self.advance_token(); *keyword }) } _ => None, } } /// If the current token is one of the expected keywords, consume the token /// and return the keyword that matches. Otherwise, return an error. pub fn expect_one_of_keywords(&mut self, keywords: &[Keyword]) -> Result { if let Some(keyword) = self.parse_one_of_keywords(keywords) { Ok(keyword) } else { let keywords: Vec = keywords.iter().map(|x| format!("{x:?}")).collect(); self.expected_ref( &format!("one of {}", keywords.join(" or ")), self.peek_token_ref(), ) } } /// If the current token is the `expected` keyword, consume the token. /// Otherwise, return an error. /// // todo deprecate in favor of expected_keyword_is pub fn expect_keyword(&mut self, expected: Keyword) -> Result { if self.parse_keyword(expected) { Ok(self.get_current_token().clone()) } else { self.expected_ref(format!("{:?}", &expected).as_str(), self.peek_token_ref()) } } /// If the current token is the `expected` keyword, consume the token. /// Otherwise, return an error. /// /// This differs from expect_keyword only in that the matched keyword /// token is not returned. pub fn expect_keyword_is(&mut self, expected: Keyword) -> Result<(), ParserError> { if self.parse_keyword(expected) { Ok(()) } else { self.expected_ref(format!("{:?}", &expected).as_str(), self.peek_token_ref()) } } /// If the current and subsequent tokens exactly match the `keywords` /// sequence, consume them and returns Ok. Otherwise, return an Error. pub fn expect_keywords(&mut self, expected: &[Keyword]) -> Result<(), ParserError> { for &kw in expected { self.expect_keyword_is(kw)?; } Ok(()) } /// Consume the next token if it matches the expected token, otherwise return false /// /// See [Self::advance_token] to consume the token unconditionally #[must_use] pub fn consume_token(&mut self, expected: &Token) -> bool { if self.peek_token_ref() == expected { self.advance_token(); true } else { false } } /// If the current and subsequent tokens exactly match the `tokens` /// sequence, consume them and returns true. Otherwise, no tokens are /// consumed and returns false #[must_use] pub fn consume_tokens(&mut self, tokens: &[Token]) -> bool { let index = self.index; for token in tokens { if !self.consume_token(token) { self.index = index; return false; } } true } /// Bail out if the current token is not an expected keyword, or consume it if it is pub fn expect_token(&mut self, expected: &Token) -> Result { if self.peek_token_ref() == expected { Ok(self.next_token()) } else { self.expected_ref(&expected.to_string(), self.peek_token_ref()) } } fn parse(s: String, loc: Location) -> Result where ::Err: Display, { s.parse::().map_err(|e| { ParserError::ParserError(format!( "Could not parse '{s}' as {}: {e}{loc}", core::any::type_name::() )) }) } /// Parse a comma-separated list of 1+ SelectItem pub fn parse_projection(&mut self) -> Result, ParserError> { // BigQuery and Snowflake allow trailing commas, but only in project lists // e.g. `SELECT 1, 2, FROM t` // https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#trailing_commas // https://docs.snowflake.com/en/release-notes/2024/8_11#select-supports-trailing-commas let trailing_commas = self.options.trailing_commas | self.dialect.supports_projection_trailing_commas(); self.parse_comma_separated_with_trailing_commas( |p| p.parse_select_item(), trailing_commas, Self::is_reserved_for_column_alias, ) } /// Parse a list of actions for `GRANT` statements. pub fn parse_actions_list(&mut self) -> Result, ParserError> { let mut values = vec![]; loop { values.push(self.parse_grant_permission()?); if !self.consume_token(&Token::Comma) { break; } else if self.options.trailing_commas { match &self.peek_token_ref().token { Token::Word(kw) if kw.keyword == Keyword::ON => { break; } Token::RParen | Token::SemiColon | Token::EOF | Token::RBracket | Token::RBrace => break, _ => continue, } } } Ok(values) } /// Parse a list of [TableWithJoins] fn parse_table_with_joins(&mut self) -> Result, ParserError> { let trailing_commas = self.dialect.supports_from_trailing_commas(); self.parse_comma_separated_with_trailing_commas( Parser::parse_table_and_joins, trailing_commas, |kw, parser| !self.dialect.is_table_factor(kw, parser), ) } /// Parse the comma of a comma-separated syntax element. /// `R` is a predicate that should return true if the next /// keyword is a reserved keyword. /// Allows for control over trailing commas /// /// Returns true if there is a next element fn is_parse_comma_separated_end_with_trailing_commas( &mut self, trailing_commas: bool, is_reserved_keyword: &R, ) -> bool where R: Fn(&Keyword, &mut Parser) -> bool, { if !self.consume_token(&Token::Comma) { true } else if trailing_commas { let token = self.next_token().token; let is_end = match token { Token::Word(ref kw) if is_reserved_keyword(&kw.keyword, self) => true, Token::RParen | Token::SemiColon | Token::EOF | Token::RBracket | Token::RBrace => { true } _ => false, }; self.prev_token(); is_end } else { false } } /// Parse the comma of a comma-separated syntax element. /// Returns true if there is a next element fn is_parse_comma_separated_end(&mut self) -> bool { self.is_parse_comma_separated_end_with_trailing_commas( self.options.trailing_commas, &Self::is_reserved_for_column_alias, ) } /// Parse a comma-separated list of 1+ items accepted by `F` pub fn parse_comma_separated(&mut self, f: F) -> Result, ParserError> where F: FnMut(&mut Parser<'a>) -> Result, { self.parse_comma_separated_with_trailing_commas( f, self.options.trailing_commas, Self::is_reserved_for_column_alias, ) } /// Parse a comma-separated list of 1+ items accepted by `F`. /// `R` is a predicate that should return true if the next /// keyword is a reserved keyword. /// Allows for control over trailing commas. fn parse_comma_separated_with_trailing_commas( &mut self, mut f: F, trailing_commas: bool, is_reserved_keyword: R, ) -> Result, ParserError> where F: FnMut(&mut Parser<'a>) -> Result, R: Fn(&Keyword, &mut Parser) -> bool, { let mut values = vec![]; loop { values.push(f(self)?); if self.is_parse_comma_separated_end_with_trailing_commas( trailing_commas, &is_reserved_keyword, ) { break; } } Ok(values) } /// Parse a period-separated list of 1+ items accepted by `F` fn parse_period_separated(&mut self, mut f: F) -> Result, ParserError> where F: FnMut(&mut Parser<'a>) -> Result, { let mut values = vec![]; loop { values.push(f(self)?); if !self.consume_token(&Token::Period) { break; } } Ok(values) } /// Parse a keyword-separated list of 1+ items accepted by `F` pub fn parse_keyword_separated( &mut self, keyword: Keyword, mut f: F, ) -> Result, ParserError> where F: FnMut(&mut Parser<'a>) -> Result, { let mut values = vec![]; loop { values.push(f(self)?); if !self.parse_keyword(keyword) { break; } } Ok(values) } /// Parse an expression enclosed in parentheses. pub fn parse_parenthesized(&mut self, mut f: F) -> Result where F: FnMut(&mut Parser<'a>) -> Result, { self.expect_token(&Token::LParen)?; let res = f(self)?; self.expect_token(&Token::RParen)?; Ok(res) } /// Parse a comma-separated list of 0+ items accepted by `F` /// * `end_token` - expected end token for the closure (e.g. [Token::RParen], [Token::RBrace] ...) pub fn parse_comma_separated0( &mut self, f: F, end_token: Token, ) -> Result, ParserError> where F: FnMut(&mut Parser<'a>) -> Result, { if self.peek_token_ref().token == end_token { return Ok(vec![]); } if self.options.trailing_commas && self.peek_tokens() == [Token::Comma, end_token] { let _ = self.consume_token(&Token::Comma); return Ok(vec![]); } self.parse_comma_separated(f) } /// Parses 0 or more statements, each followed by a semicolon. /// If the next token is any of `terminal_keywords` then no more /// statements will be parsed. pub(crate) fn parse_statement_list( &mut self, terminal_keywords: &[Keyword], ) -> Result, ParserError> { let mut values = vec![]; loop { match &self.peek_nth_token_ref(0).token { Token::EOF => break, Token::Word(w) if w.quote_style.is_none() && terminal_keywords.contains(&w.keyword) => { break; } _ => {} } values.push(self.parse_statement()?); self.expect_token(&Token::SemiColon)?; } Ok(values) } /// Default implementation of a predicate that returns true if /// the specified keyword is reserved for column alias. /// See [Dialect::is_column_alias] fn is_reserved_for_column_alias(kw: &Keyword, parser: &mut Parser) -> bool { !parser.dialect.is_column_alias(kw, parser) } /// Run a parser method `f`, reverting back to the current position if unsuccessful. /// Returns `ParserError::RecursionLimitExceeded` if `f` returns a `RecursionLimitExceeded`. /// Returns `Ok(None)` if `f` returns any other error. pub fn maybe_parse(&mut self, f: F) -> Result, ParserError> where F: FnMut(&mut Parser) -> Result, { match self.try_parse(f) { Ok(t) => Ok(Some(t)), Err(ParserError::RecursionLimitExceeded) => Err(ParserError::RecursionLimitExceeded), _ => Ok(None), } } /// Run a parser method `f`, reverting back to the current position if unsuccessful. pub fn try_parse(&mut self, mut f: F) -> Result where F: FnMut(&mut Parser) -> Result, { let index = self.index; match f(self) { Ok(t) => Ok(t), Err(e) => { // Unwind stack if limit exceeded self.index = index; Err(e) } } } /// Parse either `ALL`, `DISTINCT` or `DISTINCT ON (...)`. Returns [`None`] if `ALL` is parsed /// and results in a [`ParserError`] if both `ALL` and `DISTINCT` are found. pub fn parse_all_or_distinct(&mut self) -> Result, ParserError> { let loc = self.peek_token_ref().span.start; let distinct = match self.parse_one_of_keywords(&[Keyword::ALL, Keyword::DISTINCT]) { Some(Keyword::ALL) => { if self.peek_keyword(Keyword::DISTINCT) { return parser_err!("Cannot specify ALL then DISTINCT".to_string(), loc); } Some(Distinct::All) } Some(Keyword::DISTINCT) => { if self.peek_keyword(Keyword::ALL) { return parser_err!("Cannot specify DISTINCT then ALL".to_string(), loc); } Some(Distinct::Distinct) } None => return Ok(None), _ => return parser_err!("ALL or DISTINCT", loc), }; let Some(Distinct::Distinct) = distinct else { return Ok(distinct); }; if !self.parse_keyword(Keyword::ON) { return Ok(Some(Distinct::Distinct)); } self.expect_token(&Token::LParen)?; let col_names = if self.consume_token(&Token::RParen) { self.prev_token(); Vec::new() } else { self.parse_comma_separated(Parser::parse_expr)? }; self.expect_token(&Token::RParen)?; Ok(Some(Distinct::On(col_names))) } /// Parse a SQL CREATE statement pub fn parse_create(&mut self) -> Result { let or_replace = self.parse_keywords(&[Keyword::OR, Keyword::REPLACE]); let or_alter = self.parse_keywords(&[Keyword::OR, Keyword::ALTER]); let local = self.parse_one_of_keywords(&[Keyword::LOCAL]).is_some(); let global = self.parse_one_of_keywords(&[Keyword::GLOBAL]).is_some(); let transient = self.parse_one_of_keywords(&[Keyword::TRANSIENT]).is_some(); let global: Option = if global { Some(true) } else if local { Some(false) } else { None }; let temporary = self .parse_one_of_keywords(&[Keyword::TEMP, Keyword::TEMPORARY]) .is_some(); let persistent = dialect_of!(self is DuckDbDialect) && self.parse_one_of_keywords(&[Keyword::PERSISTENT]).is_some(); let create_view_params = self.parse_create_view_params()?; if self.peek_keywords(&[Keyword::SNAPSHOT, Keyword::TABLE]) { self.parse_create_snapshot_table().map(Into::into) } else if self.parse_keyword(Keyword::TABLE) { self.parse_create_table(or_replace, temporary, global, transient) .map(Into::into) } else if self.peek_keyword(Keyword::MATERIALIZED) || self.peek_keyword(Keyword::VIEW) || self.peek_keywords(&[Keyword::SECURE, Keyword::MATERIALIZED, Keyword::VIEW]) || self.peek_keywords(&[Keyword::SECURE, Keyword::VIEW]) { self.parse_create_view(or_alter, or_replace, temporary, create_view_params) .map(Into::into) } else if self.parse_keyword(Keyword::POLICY) { self.parse_create_policy().map(Into::into) } else if self.parse_keyword(Keyword::EXTERNAL) { self.parse_create_external_table(or_replace).map(Into::into) } else if self.parse_keyword(Keyword::FUNCTION) { self.parse_create_function(or_alter, or_replace, temporary) } else if self.parse_keyword(Keyword::DOMAIN) { self.parse_create_domain().map(Into::into) } else if self.parse_keyword(Keyword::TRIGGER) { self.parse_create_trigger(temporary, or_alter, or_replace, false) .map(Into::into) } else if self.parse_keywords(&[Keyword::CONSTRAINT, Keyword::TRIGGER]) { self.parse_create_trigger(temporary, or_alter, or_replace, true) .map(Into::into) } else if self.parse_keyword(Keyword::MACRO) { self.parse_create_macro(or_replace, temporary) } else if self.parse_keyword(Keyword::SECRET) { self.parse_create_secret(or_replace, temporary, persistent) } else if self.parse_keyword(Keyword::USER) { self.parse_create_user(or_replace).map(Into::into) } else if or_replace { self.expected_ref( "[EXTERNAL] TABLE or [MATERIALIZED] VIEW or FUNCTION after CREATE OR REPLACE", self.peek_token_ref(), ) } else if self.parse_keyword(Keyword::EXTENSION) { self.parse_create_extension().map(Into::into) } else if self.parse_keyword(Keyword::INDEX) { self.parse_create_index(false).map(Into::into) } else if self.parse_keywords(&[Keyword::UNIQUE, Keyword::INDEX]) { self.parse_create_index(true).map(Into::into) } else if self.parse_keyword(Keyword::VIRTUAL) { self.parse_create_virtual_table() } else if self.parse_keyword(Keyword::SCHEMA) { self.parse_create_schema() } else if self.parse_keyword(Keyword::DATABASE) { self.parse_create_database() } else if self.parse_keyword(Keyword::ROLE) { self.parse_create_role().map(Into::into) } else if self.parse_keyword(Keyword::SEQUENCE) { self.parse_create_sequence(temporary) } else if self.parse_keyword(Keyword::COLLATION) { self.parse_create_collation().map(Into::into) } else if self.parse_keyword(Keyword::TYPE) { self.parse_create_type() } else if self.parse_keyword(Keyword::PROCEDURE) { self.parse_create_procedure(or_alter) } else if self.parse_keyword(Keyword::CONNECTOR) { self.parse_create_connector().map(Into::into) } else if self.parse_keyword(Keyword::OPERATOR) { // Check if this is CREATE OPERATOR FAMILY or CREATE OPERATOR CLASS if self.parse_keyword(Keyword::FAMILY) { self.parse_create_operator_family().map(Into::into) } else if self.parse_keyword(Keyword::CLASS) { self.parse_create_operator_class().map(Into::into) } else { self.parse_create_operator().map(Into::into) } } else if self.parse_keyword(Keyword::SERVER) { self.parse_pg_create_server() } else { self.expected_ref("an object type after CREATE", self.peek_token_ref()) } } fn parse_create_user(&mut self, or_replace: bool) -> Result { let if_not_exists = self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]); let name = self.parse_identifier()?; let options = self .parse_key_value_options(false, &[Keyword::WITH, Keyword::TAG])? .options; let with_tags = self.parse_keyword(Keyword::WITH); let tags = if self.parse_keyword(Keyword::TAG) { self.parse_key_value_options(true, &[])?.options } else { vec![] }; Ok(CreateUser { or_replace, if_not_exists, name, options: KeyValueOptions { options, delimiter: KeyValueOptionsDelimiter::Space, }, with_tags, tags: KeyValueOptions { options: tags, delimiter: KeyValueOptionsDelimiter::Comma, }, }) } /// See [DuckDB Docs](https://duckdb.org/docs/sql/statements/create_secret.html) for more details. pub fn parse_create_secret( &mut self, or_replace: bool, temporary: bool, persistent: bool, ) -> Result { let if_not_exists = self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]); let mut storage_specifier = None; let mut name = None; if self.peek_token_ref().token != Token::LParen { if self.parse_keyword(Keyword::IN) { storage_specifier = self.parse_identifier().ok() } else { name = self.parse_identifier().ok(); } // Storage specifier may follow the name if storage_specifier.is_none() && self.peek_token_ref().token != Token::LParen && self.parse_keyword(Keyword::IN) { storage_specifier = self.parse_identifier().ok(); } } self.expect_token(&Token::LParen)?; self.expect_keyword_is(Keyword::TYPE)?; let secret_type = self.parse_identifier()?; let mut options = Vec::new(); if self.consume_token(&Token::Comma) { options.append(&mut self.parse_comma_separated(|p| { let key = p.parse_identifier()?; let value = p.parse_identifier()?; Ok(SecretOption { key, value }) })?); } self.expect_token(&Token::RParen)?; let temp = match (temporary, persistent) { (true, false) => Some(true), (false, true) => Some(false), (false, false) => None, _ => self.expected_ref("TEMPORARY or PERSISTENT", self.peek_token_ref())?, }; Ok(Statement::CreateSecret { or_replace, temporary: temp, if_not_exists, name, storage_specifier, secret_type, options, }) } /// Parse a CACHE TABLE statement pub fn parse_cache_table(&mut self) -> Result { let (mut table_flag, mut options, mut has_as, mut query) = (None, vec![], false, None); if self.parse_keyword(Keyword::TABLE) { let table_name = self.parse_object_name(false)?; if self.peek_token_ref().token != Token::EOF { if let Token::Word(word) = &self.peek_token_ref().token { if word.keyword == Keyword::OPTIONS { options = self.parse_options(Keyword::OPTIONS)? } }; if self.peek_token_ref().token != Token::EOF { let (a, q) = self.parse_as_query()?; has_as = a; query = Some(q); } Ok(Statement::Cache { table_flag, table_name, has_as, options, query, }) } else { Ok(Statement::Cache { table_flag, table_name, has_as, options, query, }) } } else { table_flag = Some(self.parse_object_name(false)?); if self.parse_keyword(Keyword::TABLE) { let table_name = self.parse_object_name(false)?; if self.peek_token_ref().token != Token::EOF { if let Token::Word(word) = &self.peek_token_ref().token { if word.keyword == Keyword::OPTIONS { options = self.parse_options(Keyword::OPTIONS)? } }; if self.peek_token_ref().token != Token::EOF { let (a, q) = self.parse_as_query()?; has_as = a; query = Some(q); } Ok(Statement::Cache { table_flag, table_name, has_as, options, query, }) } else { Ok(Statement::Cache { table_flag, table_name, has_as, options, query, }) } } else { if self.peek_token_ref().token == Token::EOF { self.prev_token(); } self.expected_ref("a `TABLE` keyword", self.peek_token_ref()) } } } /// Parse 'AS' before as query,such as `WITH XXX AS SELECT XXX` oer `CACHE TABLE AS SELECT XXX` pub fn parse_as_query(&mut self) -> Result<(bool, Box), ParserError> { match &self.peek_token_ref().token { Token::Word(word) => match word.keyword { Keyword::AS => { self.next_token(); Ok((true, self.parse_query()?)) } _ => Ok((false, self.parse_query()?)), }, _ => self.expected_ref("a QUERY statement", self.peek_token_ref()), } } /// Parse a UNCACHE TABLE statement pub fn parse_uncache_table(&mut self) -> Result { self.expect_keyword_is(Keyword::TABLE)?; let if_exists = self.parse_keywords(&[Keyword::IF, Keyword::EXISTS]); let table_name = self.parse_object_name(false)?; Ok(Statement::UNCache { table_name, if_exists, }) } /// SQLite-specific `CREATE VIRTUAL TABLE` pub fn parse_create_virtual_table(&mut self) -> Result { self.expect_keyword_is(Keyword::TABLE)?; let if_not_exists = self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]); let table_name = self.parse_object_name(false)?; self.expect_keyword_is(Keyword::USING)?; let module_name = self.parse_identifier()?; // SQLite docs note that module "arguments syntax is sufficiently // general that the arguments can be made to appear as column // definitions in a traditional CREATE TABLE statement", but // we don't implement that. let module_args = self.parse_parenthesized_column_list(Optional, false)?; Ok(Statement::CreateVirtualTable { name: table_name, if_not_exists, module_name, module_args, }) } /// Parse a `CREATE SCHEMA` statement. pub fn parse_create_schema(&mut self) -> Result { let if_not_exists = self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]); let schema_name = self.parse_schema_name()?; let default_collate_spec = if self.parse_keywords(&[Keyword::DEFAULT, Keyword::COLLATE]) { Some(self.parse_expr()?) } else { None }; let with = if self.peek_keyword(Keyword::WITH) { Some(self.parse_options(Keyword::WITH)?) } else { None }; let options = if self.peek_keyword(Keyword::OPTIONS) { Some(self.parse_options(Keyword::OPTIONS)?) } else { None }; let clone = if self.parse_keyword(Keyword::CLONE) { Some(self.parse_object_name(false)?) } else { None }; Ok(Statement::CreateSchema { schema_name, if_not_exists, with, options, default_collate_spec, clone, }) } fn parse_schema_name(&mut self) -> Result { if self.parse_keyword(Keyword::AUTHORIZATION) { Ok(SchemaName::UnnamedAuthorization(self.parse_identifier()?)) } else { let name = self.parse_object_name(false)?; if self.parse_keyword(Keyword::AUTHORIZATION) { Ok(SchemaName::NamedAuthorization( name, self.parse_identifier()?, )) } else { Ok(SchemaName::Simple(name)) } } } /// Parse a `CREATE DATABASE` statement. pub fn parse_create_database(&mut self) -> Result { let ine = self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]); let db_name = self.parse_object_name(false)?; let mut location = None; let mut managed_location = None; loop { match self.parse_one_of_keywords(&[Keyword::LOCATION, Keyword::MANAGEDLOCATION]) { Some(Keyword::LOCATION) => location = Some(self.parse_literal_string()?), Some(Keyword::MANAGEDLOCATION) => { managed_location = Some(self.parse_literal_string()?) } _ => break, } } let clone = if self.parse_keyword(Keyword::CLONE) { Some(self.parse_object_name(false)?) } else { None }; // Parse MySQL-style [DEFAULT] CHARACTER SET and [DEFAULT] COLLATE options // // Note: The docs only mention `CHARACTER SET`, but `CHARSET` is also supported. // Furthermore, MySQL will only accept one character set, raising an error if there is more // than one, but will accept multiple collations and use the last one. // // let mut default_charset = None; let mut default_collation = None; loop { let has_default = self.parse_keyword(Keyword::DEFAULT); if default_charset.is_none() && self.parse_keywords(&[Keyword::CHARACTER, Keyword::SET]) || self.parse_keyword(Keyword::CHARSET) { let _ = self.consume_token(&Token::Eq); default_charset = Some(self.parse_identifier()?.value); } else if self.parse_keyword(Keyword::COLLATE) { let _ = self.consume_token(&Token::Eq); default_collation = Some(self.parse_identifier()?.value); } else if has_default { // DEFAULT keyword not followed by CHARACTER SET, CHARSET, or COLLATE self.prev_token(); break; } else { break; } } Ok(Statement::CreateDatabase { db_name, if_not_exists: ine, location, managed_location, or_replace: false, transient: false, clone, data_retention_time_in_days: None, max_data_extension_time_in_days: None, external_volume: None, catalog: None, replace_invalid_characters: None, default_ddl_collation: None, storage_serialization_policy: None, comment: None, default_charset, default_collation, catalog_sync: None, catalog_sync_namespace_mode: None, catalog_sync_namespace_flatten_delimiter: None, with_tags: None, with_contacts: None, }) } /// Parse an optional `USING` clause for `CREATE FUNCTION`. pub fn parse_optional_create_function_using( &mut self, ) -> Result, ParserError> { if !self.parse_keyword(Keyword::USING) { return Ok(None); }; let keyword = self.expect_one_of_keywords(&[Keyword::JAR, Keyword::FILE, Keyword::ARCHIVE])?; let uri = self.parse_literal_string()?; match keyword { Keyword::JAR => Ok(Some(CreateFunctionUsing::Jar(uri))), Keyword::FILE => Ok(Some(CreateFunctionUsing::File(uri))), Keyword::ARCHIVE => Ok(Some(CreateFunctionUsing::Archive(uri))), _ => self.expected( "JAR, FILE or ARCHIVE, got {:?}", TokenWithSpan::wrap(Token::make_keyword(format!("{keyword:?}").as_str())), ), } } /// Parse a `CREATE FUNCTION` statement. pub fn parse_create_function( &mut self, or_alter: bool, or_replace: bool, temporary: bool, ) -> Result { if dialect_of!(self is HiveDialect) { self.parse_hive_create_function(or_replace, temporary) .map(Into::into) } else if dialect_of!(self is PostgreSqlDialect | GenericDialect) { self.parse_postgres_create_function(or_replace, temporary) .map(Into::into) } else if dialect_of!(self is DuckDbDialect) { self.parse_create_macro(or_replace, temporary) } else if dialect_of!(self is BigQueryDialect) { self.parse_bigquery_create_function(or_replace, temporary) .map(Into::into) } else if dialect_of!(self is MsSqlDialect) { self.parse_mssql_create_function(or_alter, or_replace, temporary) .map(Into::into) } else { self.prev_token(); self.expected_ref("an object type after CREATE", self.peek_token_ref()) } } /// Parse `CREATE FUNCTION` for [PostgreSQL] /// /// [PostgreSQL]: https://www.postgresql.org/docs/15/sql-createfunction.html fn parse_postgres_create_function( &mut self, or_replace: bool, temporary: bool, ) -> Result { let name = self.parse_object_name(false)?; self.expect_token(&Token::LParen)?; let args = if Token::RParen != self.peek_token_ref().token { self.parse_comma_separated(Parser::parse_function_arg)? } else { vec![] }; self.expect_token(&Token::RParen)?; let return_type = if self.parse_keyword(Keyword::RETURNS) { Some(self.parse_function_return_type()?) } else { None }; #[derive(Default)] struct Body { language: Option, behavior: Option, function_body: Option, called_on_null: Option, parallel: Option, security: Option, } let mut body = Body::default(); let mut set_params: Vec = Vec::new(); loop { fn ensure_not_set(field: &Option, name: &str) -> Result<(), ParserError> { if field.is_some() { return Err(ParserError::ParserError(format!( "{name} specified more than once", ))); } Ok(()) } if self.parse_keyword(Keyword::AS) { ensure_not_set(&body.function_body, "AS")?; body.function_body = Some(self.parse_create_function_body_string()?); } else if self.parse_keyword(Keyword::LANGUAGE) { ensure_not_set(&body.language, "LANGUAGE")?; body.language = Some(self.parse_identifier()?); } else if self.parse_keyword(Keyword::IMMUTABLE) { ensure_not_set(&body.behavior, "IMMUTABLE | STABLE | VOLATILE")?; body.behavior = Some(FunctionBehavior::Immutable); } else if self.parse_keyword(Keyword::STABLE) { ensure_not_set(&body.behavior, "IMMUTABLE | STABLE | VOLATILE")?; body.behavior = Some(FunctionBehavior::Stable); } else if self.parse_keyword(Keyword::VOLATILE) { ensure_not_set(&body.behavior, "IMMUTABLE | STABLE | VOLATILE")?; body.behavior = Some(FunctionBehavior::Volatile); } else if self.parse_keywords(&[ Keyword::CALLED, Keyword::ON, Keyword::NULL, Keyword::INPUT, ]) { ensure_not_set( &body.called_on_null, "CALLED ON NULL INPUT | RETURNS NULL ON NULL INPUT | STRICT", )?; body.called_on_null = Some(FunctionCalledOnNull::CalledOnNullInput); } else if self.parse_keywords(&[ Keyword::RETURNS, Keyword::NULL, Keyword::ON, Keyword::NULL, Keyword::INPUT, ]) { ensure_not_set( &body.called_on_null, "CALLED ON NULL INPUT | RETURNS NULL ON NULL INPUT | STRICT", )?; body.called_on_null = Some(FunctionCalledOnNull::ReturnsNullOnNullInput); } else if self.parse_keyword(Keyword::STRICT) { ensure_not_set( &body.called_on_null, "CALLED ON NULL INPUT | RETURNS NULL ON NULL INPUT | STRICT", )?; body.called_on_null = Some(FunctionCalledOnNull::Strict); } else if self.parse_keyword(Keyword::PARALLEL) { ensure_not_set(&body.parallel, "PARALLEL { UNSAFE | RESTRICTED | SAFE }")?; if self.parse_keyword(Keyword::UNSAFE) { body.parallel = Some(FunctionParallel::Unsafe); } else if self.parse_keyword(Keyword::RESTRICTED) { body.parallel = Some(FunctionParallel::Restricted); } else if self.parse_keyword(Keyword::SAFE) { body.parallel = Some(FunctionParallel::Safe); } else { return self .expected_ref("one of UNSAFE | RESTRICTED | SAFE", self.peek_token_ref()); } } else if self.parse_keyword(Keyword::SECURITY) { ensure_not_set(&body.security, "SECURITY { DEFINER | INVOKER }")?; if self.parse_keyword(Keyword::DEFINER) { body.security = Some(FunctionSecurity::Definer); } else if self.parse_keyword(Keyword::INVOKER) { body.security = Some(FunctionSecurity::Invoker); } else { return self.expected_ref("DEFINER or INVOKER", self.peek_token_ref()); } } else if self.parse_keyword(Keyword::SET) { let name = self.parse_object_name(false)?; let value = if self.parse_keywords(&[Keyword::FROM, Keyword::CURRENT]) { FunctionSetValue::FromCurrent } else { if !self.consume_token(&Token::Eq) && !self.parse_keyword(Keyword::TO) { return self.expected_ref("= or TO", self.peek_token_ref()); } if self.parse_keyword(Keyword::DEFAULT) { FunctionSetValue::Default } else { let values = self.parse_comma_separated(Parser::parse_expr)?; FunctionSetValue::Values(values) } }; set_params.push(FunctionDefinitionSetParam { name, value }); } else if self.parse_keyword(Keyword::RETURN) { ensure_not_set(&body.function_body, "RETURN")?; body.function_body = Some(CreateFunctionBody::Return(self.parse_expr()?)); } else { break; } } Ok(CreateFunction { or_alter: false, or_replace, temporary, name, args: Some(args), return_type, behavior: body.behavior, called_on_null: body.called_on_null, parallel: body.parallel, security: body.security, set_params, language: body.language, function_body: body.function_body, if_not_exists: false, using: None, determinism_specifier: None, options: None, remote_connection: None, }) } /// Parse `CREATE FUNCTION` for [Hive] /// /// [Hive]: https://cwiki.apache.org/confluence/display/hive/languagemanual+ddl#LanguageManualDDL-Create/Drop/ReloadFunction fn parse_hive_create_function( &mut self, or_replace: bool, temporary: bool, ) -> Result { let name = self.parse_object_name(false)?; self.expect_keyword_is(Keyword::AS)?; let body = self.parse_create_function_body_string()?; let using = self.parse_optional_create_function_using()?; Ok(CreateFunction { or_alter: false, or_replace, temporary, name, function_body: Some(body), using, if_not_exists: false, args: None, return_type: None, behavior: None, called_on_null: None, parallel: None, security: None, set_params: vec![], language: None, determinism_specifier: None, options: None, remote_connection: None, }) } /// Parse `CREATE FUNCTION` for [BigQuery] /// /// [BigQuery]: https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language#create_function_statement fn parse_bigquery_create_function( &mut self, or_replace: bool, temporary: bool, ) -> Result { let if_not_exists = self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]); let (name, args) = self.parse_create_function_name_and_params()?; let return_type = if self.parse_keyword(Keyword::RETURNS) { Some(self.parse_function_return_type()?) } else { None }; let determinism_specifier = if self.parse_keyword(Keyword::DETERMINISTIC) { Some(FunctionDeterminismSpecifier::Deterministic) } else if self.parse_keywords(&[Keyword::NOT, Keyword::DETERMINISTIC]) { Some(FunctionDeterminismSpecifier::NotDeterministic) } else { None }; let language = if self.parse_keyword(Keyword::LANGUAGE) { Some(self.parse_identifier()?) } else { None }; let remote_connection = if self.parse_keywords(&[Keyword::REMOTE, Keyword::WITH, Keyword::CONNECTION]) { Some(self.parse_object_name(false)?) } else { None }; // `OPTIONS` may come before of after the function body but // may be specified at most once. let mut options = self.maybe_parse_options(Keyword::OPTIONS)?; let function_body = if remote_connection.is_none() { self.expect_keyword_is(Keyword::AS)?; let expr = self.parse_expr()?; if options.is_none() { options = self.maybe_parse_options(Keyword::OPTIONS)?; Some(CreateFunctionBody::AsBeforeOptions { body: expr, link_symbol: None, }) } else { Some(CreateFunctionBody::AsAfterOptions(expr)) } } else { None }; Ok(CreateFunction { or_alter: false, or_replace, temporary, if_not_exists, name, args: Some(args), return_type, function_body, language, determinism_specifier, options, remote_connection, using: None, behavior: None, called_on_null: None, parallel: None, security: None, set_params: vec![], }) } /// Parse `CREATE FUNCTION` for [MsSql] /// /// [MsSql]: https://learn.microsoft.com/en-us/sql/t-sql/statements/create-function-transact-sql fn parse_mssql_create_function( &mut self, or_alter: bool, or_replace: bool, temporary: bool, ) -> Result { let (name, args) = self.parse_create_function_name_and_params()?; self.expect_keyword(Keyword::RETURNS)?; let return_table = self.maybe_parse(|p| { let return_table_name = p.parse_identifier()?; p.expect_keyword_is(Keyword::TABLE)?; p.prev_token(); let table_column_defs = match p.parse_data_type()? { DataType::Table(Some(table_column_defs)) if !table_column_defs.is_empty() => { table_column_defs } _ => parser_err!( "Expected table column definitions after TABLE keyword", p.peek_token_ref().span.start )?, }; Ok(DataType::NamedTable { name: ObjectName(vec![ObjectNamePart::Identifier(return_table_name)]), columns: table_column_defs, }) })?; let data_type = match return_table { Some(table_type) => table_type, None => self.parse_data_type()?, }; let return_type = Some(FunctionReturnType::DataType(data_type)); let _ = self.parse_keyword(Keyword::AS); let function_body = if self.peek_keyword(Keyword::BEGIN) { let begin_token = self.expect_keyword(Keyword::BEGIN)?; let statements = self.parse_statement_list(&[Keyword::END])?; let end_token = self.expect_keyword(Keyword::END)?; Some(CreateFunctionBody::AsBeginEnd(BeginEndStatements { begin_token: AttachedToken(begin_token), statements, end_token: AttachedToken(end_token), })) } else if self.parse_keyword(Keyword::RETURN) { if self.peek_token_ref().token == Token::LParen { Some(CreateFunctionBody::AsReturnExpr(self.parse_expr()?)) } else if self.peek_keyword(Keyword::SELECT) { let select = self.parse_select()?; Some(CreateFunctionBody::AsReturnSelect(select)) } else { parser_err!( "Expected a subquery (or bare SELECT statement) after RETURN", self.peek_token_ref().span.start )? } } else { parser_err!("Unparsable function body", self.peek_token_ref().span.start)? }; Ok(CreateFunction { or_alter, or_replace, temporary, if_not_exists: false, name, args: Some(args), return_type, function_body, language: None, determinism_specifier: None, options: None, remote_connection: None, using: None, behavior: None, called_on_null: None, parallel: None, security: None, set_params: vec![], }) } fn parse_function_return_type(&mut self) -> Result { if self.parse_keyword(Keyword::SETOF) { Ok(FunctionReturnType::SetOf(self.parse_data_type()?)) } else { Ok(FunctionReturnType::DataType(self.parse_data_type()?)) } } fn parse_create_function_name_and_params( &mut self, ) -> Result<(ObjectName, Vec), ParserError> { let name = self.parse_object_name(false)?; let parse_function_param = |parser: &mut Parser| -> Result { let name = parser.parse_identifier()?; let data_type = parser.parse_data_type()?; let default_expr = if parser.consume_token(&Token::Eq) { Some(parser.parse_expr()?) } else { None }; Ok(OperateFunctionArg { mode: None, name: Some(name), data_type, default_expr, }) }; self.expect_token(&Token::LParen)?; let args = self.parse_comma_separated0(parse_function_param, Token::RParen)?; self.expect_token(&Token::RParen)?; Ok((name, args)) } fn parse_function_arg(&mut self) -> Result { let mode = if self.parse_keyword(Keyword::IN) { Some(ArgMode::In) } else if self.parse_keyword(Keyword::OUT) { Some(ArgMode::Out) } else if self.parse_keyword(Keyword::INOUT) { Some(ArgMode::InOut) } else if self.parse_keyword(Keyword::VARIADIC) { Some(ArgMode::Variadic) } else { None }; // parse: [ argname ] argtype let mut name = None; let mut data_type = self.parse_data_type()?; // To check whether the first token is a name or a type, we need to // peek the next token, which if it is another type keyword, then the // first token is a name and not a type in itself. let data_type_idx = self.get_current_index(); // DEFAULT will be parsed as `DataType::Custom`, which is undesirable in this context fn parse_data_type_no_default(parser: &mut Parser) -> Result { if parser.peek_keyword(Keyword::DEFAULT) { // This dummy error is ignored in `maybe_parse` parser_err!( "The DEFAULT keyword is not a type", parser.peek_token_ref().span.start ) } else { parser.parse_data_type() } } if let Some(next_data_type) = self.maybe_parse(parse_data_type_no_default)? { let token = self.token_at(data_type_idx); // We ensure that the token is a `Word` token, and not other special tokens. if !matches!(token.token, Token::Word(_)) { return self.expected("a name or type", token.clone()); } name = Some(Ident::new(token.to_string())); data_type = next_data_type; } let default_expr = if self.parse_keyword(Keyword::DEFAULT) || self.consume_token(&Token::Eq) { Some(self.parse_expr()?) } else { None }; Ok(OperateFunctionArg { mode, name, data_type, default_expr, }) } fn parse_aggregate_function_arg(&mut self) -> Result { let mode = if self.parse_keyword(Keyword::IN) { Some(ArgMode::In) } else { if self .peek_one_of_keywords(&[Keyword::OUT, Keyword::INOUT, Keyword::VARIADIC]) .is_some() { return self.expected_ref( "IN or argument type in aggregate signature", self.peek_token_ref(), ); } None }; // Parse: [ argname ] argtype, but do not consume ORDER from // `... argtype ORDER BY ...` as a type-name disambiguator. let mut name = None; let mut data_type = self.parse_data_type()?; let data_type_idx = self.get_current_index(); fn parse_data_type_for_aggregate_arg(parser: &mut Parser) -> Result { if parser.peek_keyword(Keyword::DEFAULT) || parser.peek_keyword(Keyword::ORDER) || parser.peek_token_ref().token == Token::Comma || parser.peek_token_ref().token == Token::RParen { // Dummy error ignored by maybe_parse parser_err!( "The current token cannot start an aggregate argument type", parser.peek_token_ref().span.start ) } else { parser.parse_data_type() } } if let Some(next_data_type) = self.maybe_parse(parse_data_type_for_aggregate_arg)? { let token = self.token_at(data_type_idx); if !matches!(token.token, Token::Word(_)) { return self.expected("a name or type", token.clone()); } name = Some(Ident::new(token.to_string())); data_type = next_data_type; } if self.peek_keyword(Keyword::DEFAULT) || self.peek_token_ref().token == Token::Eq { return self.expected_ref( "',' or ')' or ORDER BY after aggregate argument type", self.peek_token_ref(), ); } Ok(OperateFunctionArg { mode, name, data_type, default_expr: None, }) } /// Parse statements of the DropTrigger type such as: /// /// ```sql /// DROP TRIGGER [ IF EXISTS ] name ON table_name [ CASCADE | RESTRICT ] /// ``` pub fn parse_drop_trigger(&mut self) -> Result { if !dialect_of!(self is PostgreSqlDialect | SQLiteDialect | GenericDialect | MySqlDialect | MsSqlDialect) { self.prev_token(); return self.expected_ref("an object type after DROP", self.peek_token_ref()); } let if_exists = self.parse_keywords(&[Keyword::IF, Keyword::EXISTS]); let trigger_name = self.parse_object_name(false)?; let table_name = if self.parse_keyword(Keyword::ON) { Some(self.parse_object_name(false)?) } else { None }; let option = match self.parse_one_of_keywords(&[Keyword::CASCADE, Keyword::RESTRICT]) { Some(Keyword::CASCADE) => Some(ReferentialAction::Cascade), Some(Keyword::RESTRICT) => Some(ReferentialAction::Restrict), Some(unexpected_keyword) => return Err(ParserError::ParserError( format!("Internal parser error: expected any of {{CASCADE, RESTRICT}}, got {unexpected_keyword:?}"), )), None => None, }; Ok(DropTrigger { if_exists, trigger_name, table_name, option, }) } /// Parse a `CREATE TRIGGER` statement. pub fn parse_create_trigger( &mut self, temporary: bool, or_alter: bool, or_replace: bool, is_constraint: bool, ) -> Result { if !dialect_of!(self is PostgreSqlDialect | SQLiteDialect | GenericDialect | MySqlDialect | MsSqlDialect) { self.prev_token(); return self.expected_ref("an object type after CREATE", self.peek_token_ref()); } let name = self.parse_object_name(false)?; let period = self.maybe_parse(|parser| parser.parse_trigger_period())?; let events = self.parse_keyword_separated(Keyword::OR, Parser::parse_trigger_event)?; self.expect_keyword_is(Keyword::ON)?; let table_name = self.parse_object_name(false)?; let referenced_table_name = if self.parse_keyword(Keyword::FROM) { self.parse_object_name(true).ok() } else { None }; let characteristics = self.parse_constraint_characteristics()?; let mut referencing = vec![]; if self.parse_keyword(Keyword::REFERENCING) { while let Some(refer) = self.parse_trigger_referencing()? { referencing.push(refer); } } let trigger_object = if self.parse_keyword(Keyword::FOR) { let include_each = self.parse_keyword(Keyword::EACH); let trigger_object = match self.expect_one_of_keywords(&[Keyword::ROW, Keyword::STATEMENT])? { Keyword::ROW => TriggerObject::Row, Keyword::STATEMENT => TriggerObject::Statement, unexpected_keyword => return Err(ParserError::ParserError( format!("Internal parser error: unexpected keyword `{unexpected_keyword}` in ROW/STATEMENT"), )), }; Some(if include_each { TriggerObjectKind::ForEach(trigger_object) } else { TriggerObjectKind::For(trigger_object) }) } else { let _ = self.parse_keyword(Keyword::FOR); None }; let condition = self .parse_keyword(Keyword::WHEN) .then(|| self.parse_expr()) .transpose()?; let mut exec_body = None; let mut statements = None; if self.parse_keyword(Keyword::EXECUTE) { exec_body = Some(self.parse_trigger_exec_body()?); } else { statements = Some(self.parse_conditional_statements(&[Keyword::END])?); } Ok(CreateTrigger { or_alter, temporary, or_replace, is_constraint, name, period, period_before_table: true, events, table_name, referenced_table_name, referencing, trigger_object, condition, exec_body, statements_as: false, statements, characteristics, }) } /// Parse the period part of a trigger (`BEFORE`, `AFTER`, etc.). pub fn parse_trigger_period(&mut self) -> Result { Ok( match self.expect_one_of_keywords(&[ Keyword::FOR, Keyword::BEFORE, Keyword::AFTER, Keyword::INSTEAD, ])? { Keyword::FOR => TriggerPeriod::For, Keyword::BEFORE => TriggerPeriod::Before, Keyword::AFTER => TriggerPeriod::After, Keyword::INSTEAD => self .expect_keyword_is(Keyword::OF) .map(|_| TriggerPeriod::InsteadOf)?, unexpected_keyword => return Err(ParserError::ParserError( format!("Internal parser error: unexpected keyword `{unexpected_keyword}` in trigger period"), )), }, ) } /// Parse the event part of a trigger (`INSERT`, `UPDATE`, etc.). pub fn parse_trigger_event(&mut self) -> Result { Ok( match self.expect_one_of_keywords(&[ Keyword::INSERT, Keyword::UPDATE, Keyword::DELETE, Keyword::TRUNCATE, ])? { Keyword::INSERT => TriggerEvent::Insert, Keyword::UPDATE => { if self.parse_keyword(Keyword::OF) { let cols = self.parse_comma_separated(Parser::parse_identifier)?; TriggerEvent::Update(cols) } else { TriggerEvent::Update(vec![]) } } Keyword::DELETE => TriggerEvent::Delete, Keyword::TRUNCATE => TriggerEvent::Truncate, unexpected_keyword => return Err(ParserError::ParserError( format!("Internal parser error: unexpected keyword `{unexpected_keyword}` in trigger event"), )), }, ) } /// Parse the `REFERENCING` clause of a trigger. pub fn parse_trigger_referencing(&mut self) -> Result, ParserError> { let refer_type = match self.parse_one_of_keywords(&[Keyword::OLD, Keyword::NEW]) { Some(Keyword::OLD) if self.parse_keyword(Keyword::TABLE) => { TriggerReferencingType::OldTable } Some(Keyword::NEW) if self.parse_keyword(Keyword::TABLE) => { TriggerReferencingType::NewTable } _ => { return Ok(None); } }; let is_as = self.parse_keyword(Keyword::AS); let transition_relation_name = self.parse_object_name(false)?; Ok(Some(TriggerReferencing { refer_type, is_as, transition_relation_name, })) } /// Parse the execution body of a trigger (`FUNCTION` or `PROCEDURE`). pub fn parse_trigger_exec_body(&mut self) -> Result { Ok(TriggerExecBody { exec_type: match self .expect_one_of_keywords(&[Keyword::FUNCTION, Keyword::PROCEDURE])? { Keyword::FUNCTION => TriggerExecBodyType::Function, Keyword::PROCEDURE => TriggerExecBodyType::Procedure, unexpected_keyword => return Err(ParserError::ParserError( format!("Internal parser error: unexpected keyword `{unexpected_keyword}` in trigger exec body"), )), }, func_desc: self.parse_function_desc()?, }) } /// Parse a `CREATE MACRO` statement. pub fn parse_create_macro( &mut self, or_replace: bool, temporary: bool, ) -> Result { if dialect_of!(self is DuckDbDialect | GenericDialect) { let name = self.parse_object_name(false)?; self.expect_token(&Token::LParen)?; let args = if self.consume_token(&Token::RParen) { self.prev_token(); None } else { Some(self.parse_comma_separated(Parser::parse_macro_arg)?) }; self.expect_token(&Token::RParen)?; self.expect_keyword_is(Keyword::AS)?; Ok(Statement::CreateMacro { or_replace, temporary, name, args, definition: if self.parse_keyword(Keyword::TABLE) { MacroDefinition::Table(self.parse_query()?) } else { MacroDefinition::Expr(self.parse_expr()?) }, }) } else { self.prev_token(); self.expected_ref("an object type after CREATE", self.peek_token_ref()) } } fn parse_macro_arg(&mut self) -> Result { let name = self.parse_identifier()?; let default_expr = if self.consume_token(&Token::Assignment) || self.consume_token(&Token::RArrow) { Some(self.parse_expr()?) } else { None }; Ok(MacroArg { name, default_expr }) } /// Parse a `CREATE EXTERNAL TABLE` statement. pub fn parse_create_external_table( &mut self, or_replace: bool, ) -> Result { self.expect_keyword_is(Keyword::TABLE)?; let if_not_exists = self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]); let table_name = self.parse_object_name(false)?; let (columns, constraints) = self.parse_columns()?; let hive_distribution = self.parse_hive_distribution()?; let hive_formats = self.parse_hive_formats()?; let file_format = if let Some(ref hf) = hive_formats { if let Some(ref ff) = hf.storage { match ff { HiveIOFormat::FileFormat { format } => Some(*format), _ => None, } } else { None } } else { None }; let location = hive_formats.as_ref().and_then(|hf| hf.location.clone()); let table_properties = self.parse_options(Keyword::TBLPROPERTIES)?; let table_options = if !table_properties.is_empty() { CreateTableOptions::TableProperties(table_properties) } else if let Some(options) = self.maybe_parse_options(Keyword::OPTIONS)? { CreateTableOptions::Options(options) } else { CreateTableOptions::None }; Ok(CreateTableBuilder::new(table_name) .columns(columns) .constraints(constraints) .hive_distribution(hive_distribution) .hive_formats(hive_formats) .table_options(table_options) .or_replace(or_replace) .if_not_exists(if_not_exists) .external(true) .file_format(file_format) .location(location) .build()) } /// Parse `CREATE SNAPSHOT TABLE` statement. /// /// pub fn parse_create_snapshot_table(&mut self) -> Result { self.expect_keywords(&[Keyword::SNAPSHOT, Keyword::TABLE])?; let if_not_exists = self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]); let table_name = self.parse_object_name(true)?; self.expect_keyword_is(Keyword::CLONE)?; let clone = Some(self.parse_object_name(true)?); let version = if self.parse_keywords(&[Keyword::FOR, Keyword::SYSTEM_TIME, Keyword::AS, Keyword::OF]) { Some(TableVersion::ForSystemTimeAsOf(self.parse_expr()?)) } else { None }; let table_options = if let Some(options) = self.maybe_parse_options(Keyword::OPTIONS)? { CreateTableOptions::Options(options) } else { CreateTableOptions::None }; Ok(CreateTableBuilder::new(table_name) .snapshot(true) .if_not_exists(if_not_exists) .clone_clause(clone) .version(version) .table_options(table_options) .build()) } /// Parse a file format for external tables. pub fn parse_file_format(&mut self) -> Result { let next_token = self.next_token(); match &next_token.token { Token::Word(w) => match w.keyword { Keyword::AVRO => Ok(FileFormat::AVRO), Keyword::JSONFILE => Ok(FileFormat::JSONFILE), Keyword::ORC => Ok(FileFormat::ORC), Keyword::PARQUET => Ok(FileFormat::PARQUET), Keyword::RCFILE => Ok(FileFormat::RCFILE), Keyword::SEQUENCEFILE => Ok(FileFormat::SEQUENCEFILE), Keyword::TEXTFILE => Ok(FileFormat::TEXTFILE), _ => self.expected("fileformat", next_token), }, _ => self.expected("fileformat", next_token), } } fn parse_analyze_format_kind(&mut self) -> Result { if self.consume_token(&Token::Eq) { Ok(AnalyzeFormatKind::Assignment(self.parse_analyze_format()?)) } else { Ok(AnalyzeFormatKind::Keyword(self.parse_analyze_format()?)) } } /// Parse an `ANALYZE FORMAT`. pub fn parse_analyze_format(&mut self) -> Result { let next_token = self.next_token(); match &next_token.token { Token::Word(w) => match w.keyword { Keyword::TEXT => Ok(AnalyzeFormat::TEXT), Keyword::GRAPHVIZ => Ok(AnalyzeFormat::GRAPHVIZ), Keyword::JSON => Ok(AnalyzeFormat::JSON), Keyword::TREE => Ok(AnalyzeFormat::TREE), _ => self.expected("fileformat", next_token), }, _ => self.expected("fileformat", next_token), } } /// Parse a `CREATE VIEW` statement. pub fn parse_create_view( &mut self, or_alter: bool, or_replace: bool, temporary: bool, create_view_params: Option, ) -> Result { let secure = self.parse_keyword(Keyword::SECURE); let materialized = self.parse_keyword(Keyword::MATERIALIZED); self.expect_keyword_is(Keyword::VIEW)?; let allow_unquoted_hyphen = dialect_of!(self is BigQueryDialect); // Tries to parse IF NOT EXISTS either before name or after name // Name before IF NOT EXISTS is supported by snowflake but undocumented let if_not_exists_first = self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]); let name = self.parse_object_name(allow_unquoted_hyphen)?; let name_before_not_exists = !if_not_exists_first && self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]); let if_not_exists = if_not_exists_first || name_before_not_exists; let copy_grants = self.parse_keywords(&[Keyword::COPY, Keyword::GRANTS]); // Many dialects support `OR ALTER` right after `CREATE`, but we don't (yet). // ANSI SQL and Postgres support RECURSIVE here, but we don't support it either. let columns = self.parse_view_columns()?; let mut options = CreateTableOptions::None; let with_options = self.parse_options(Keyword::WITH)?; if !with_options.is_empty() { options = CreateTableOptions::With(with_options); } let cluster_by = if self.parse_keyword(Keyword::CLUSTER) { self.expect_keyword_is(Keyword::BY)?; self.parse_parenthesized_column_list(Optional, false)? } else { vec![] }; if dialect_of!(self is BigQueryDialect | GenericDialect) { if let Some(opts) = self.maybe_parse_options(Keyword::OPTIONS)? { if !opts.is_empty() { options = CreateTableOptions::Options(opts); } }; } let to = if dialect_of!(self is ClickHouseDialect | GenericDialect) && self.parse_keyword(Keyword::TO) { Some(self.parse_object_name(false)?) } else { None }; let comment = if self.dialect.supports_create_view_comment_syntax() && self.parse_keyword(Keyword::COMMENT) { self.expect_token(&Token::Eq)?; Some(self.parse_comment_value()?) } else { None }; self.expect_keyword_is(Keyword::AS)?; let query = self.parse_query()?; // Optional `WITH [ CASCADED | LOCAL ] CHECK OPTION` is widely supported here. let with_no_schema_binding = dialect_of!(self is RedshiftSqlDialect | GenericDialect) && self.parse_keywords(&[ Keyword::WITH, Keyword::NO, Keyword::SCHEMA, Keyword::BINDING, ]); Ok(CreateView { or_alter, name, columns, query, materialized, secure, or_replace, options, cluster_by, comment, with_no_schema_binding, if_not_exists, temporary, copy_grants, to, params: create_view_params, name_before_not_exists, }) } /// Parse optional parameters for the `CREATE VIEW` statement supported by [MySQL]. /// /// [MySQL]: https://dev.mysql.com/doc/refman/9.1/en/create-view.html fn parse_create_view_params(&mut self) -> Result, ParserError> { let algorithm = if self.parse_keyword(Keyword::ALGORITHM) { self.expect_token(&Token::Eq)?; Some( match self.expect_one_of_keywords(&[ Keyword::UNDEFINED, Keyword::MERGE, Keyword::TEMPTABLE, ])? { Keyword::UNDEFINED => CreateViewAlgorithm::Undefined, Keyword::MERGE => CreateViewAlgorithm::Merge, Keyword::TEMPTABLE => CreateViewAlgorithm::TempTable, _ => { self.prev_token(); let found = self.next_token(); return self .expected("UNDEFINED or MERGE or TEMPTABLE after ALGORITHM =", found); } }, ) } else { None }; let definer = if self.parse_keyword(Keyword::DEFINER) { self.expect_token(&Token::Eq)?; Some(self.parse_grantee_name()?) } else { None }; let security = if self.parse_keywords(&[Keyword::SQL, Keyword::SECURITY]) { Some( match self.expect_one_of_keywords(&[Keyword::DEFINER, Keyword::INVOKER])? { Keyword::DEFINER => CreateViewSecurity::Definer, Keyword::INVOKER => CreateViewSecurity::Invoker, _ => { self.prev_token(); let found = self.next_token(); return self.expected("DEFINER or INVOKER after SQL SECURITY", found); } }, ) } else { None }; if algorithm.is_some() || definer.is_some() || security.is_some() { Ok(Some(CreateViewParams { algorithm, definer, security, })) } else { Ok(None) } } /// Parse a `CREATE ROLE` statement. pub fn parse_create_role(&mut self) -> Result { let if_not_exists = self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]); let names = self.parse_comma_separated(|p| p.parse_object_name(false))?; let _ = self.parse_keyword(Keyword::WITH); // [ WITH ] let optional_keywords = if dialect_of!(self is MsSqlDialect) { vec![Keyword::AUTHORIZATION] } else if dialect_of!(self is PostgreSqlDialect) { vec![ Keyword::LOGIN, Keyword::NOLOGIN, Keyword::INHERIT, Keyword::NOINHERIT, Keyword::BYPASSRLS, Keyword::NOBYPASSRLS, Keyword::PASSWORD, Keyword::CREATEDB, Keyword::NOCREATEDB, Keyword::CREATEROLE, Keyword::NOCREATEROLE, Keyword::SUPERUSER, Keyword::NOSUPERUSER, Keyword::REPLICATION, Keyword::NOREPLICATION, Keyword::CONNECTION, Keyword::VALID, Keyword::IN, Keyword::ROLE, Keyword::ADMIN, Keyword::USER, ] } else { vec![] }; // MSSQL let mut authorization_owner = None; // Postgres let mut login = None; let mut inherit = None; let mut bypassrls = None; let mut password = None; let mut create_db = None; let mut create_role = None; let mut superuser = None; let mut replication = None; let mut connection_limit = None; let mut valid_until = None; let mut in_role = vec![]; let mut in_group = vec![]; let mut role = vec![]; let mut user = vec![]; let mut admin = vec![]; while let Some(keyword) = self.parse_one_of_keywords(&optional_keywords) { let loc = self .tokens .get(self.index - 1) .map_or(Location { line: 0, column: 0 }, |t| t.span.start); match keyword { Keyword::AUTHORIZATION => { if authorization_owner.is_some() { parser_err!("Found multiple AUTHORIZATION", loc) } else { authorization_owner = Some(self.parse_object_name(false)?); Ok(()) } } Keyword::LOGIN | Keyword::NOLOGIN => { if login.is_some() { parser_err!("Found multiple LOGIN or NOLOGIN", loc) } else { login = Some(keyword == Keyword::LOGIN); Ok(()) } } Keyword::INHERIT | Keyword::NOINHERIT => { if inherit.is_some() { parser_err!("Found multiple INHERIT or NOINHERIT", loc) } else { inherit = Some(keyword == Keyword::INHERIT); Ok(()) } } Keyword::BYPASSRLS | Keyword::NOBYPASSRLS => { if bypassrls.is_some() { parser_err!("Found multiple BYPASSRLS or NOBYPASSRLS", loc) } else { bypassrls = Some(keyword == Keyword::BYPASSRLS); Ok(()) } } Keyword::CREATEDB | Keyword::NOCREATEDB => { if create_db.is_some() { parser_err!("Found multiple CREATEDB or NOCREATEDB", loc) } else { create_db = Some(keyword == Keyword::CREATEDB); Ok(()) } } Keyword::CREATEROLE | Keyword::NOCREATEROLE => { if create_role.is_some() { parser_err!("Found multiple CREATEROLE or NOCREATEROLE", loc) } else { create_role = Some(keyword == Keyword::CREATEROLE); Ok(()) } } Keyword::SUPERUSER | Keyword::NOSUPERUSER => { if superuser.is_some() { parser_err!("Found multiple SUPERUSER or NOSUPERUSER", loc) } else { superuser = Some(keyword == Keyword::SUPERUSER); Ok(()) } } Keyword::REPLICATION | Keyword::NOREPLICATION => { if replication.is_some() { parser_err!("Found multiple REPLICATION or NOREPLICATION", loc) } else { replication = Some(keyword == Keyword::REPLICATION); Ok(()) } } Keyword::PASSWORD => { if password.is_some() { parser_err!("Found multiple PASSWORD", loc) } else { password = if self.parse_keyword(Keyword::NULL) { Some(Password::NullPassword) } else { Some(Password::Password(Expr::Value(self.parse_value()?))) }; Ok(()) } } Keyword::CONNECTION => { self.expect_keyword_is(Keyword::LIMIT)?; if connection_limit.is_some() { parser_err!("Found multiple CONNECTION LIMIT", loc) } else { connection_limit = Some(Expr::Value(self.parse_number_value()?)); Ok(()) } } Keyword::VALID => { self.expect_keyword_is(Keyword::UNTIL)?; if valid_until.is_some() { parser_err!("Found multiple VALID UNTIL", loc) } else { valid_until = Some(Expr::Value(self.parse_value()?)); Ok(()) } } Keyword::IN => { if self.parse_keyword(Keyword::ROLE) { if !in_role.is_empty() { parser_err!("Found multiple IN ROLE", loc) } else { in_role = self.parse_comma_separated(|p| p.parse_identifier())?; Ok(()) } } else if self.parse_keyword(Keyword::GROUP) { if !in_group.is_empty() { parser_err!("Found multiple IN GROUP", loc) } else { in_group = self.parse_comma_separated(|p| p.parse_identifier())?; Ok(()) } } else { self.expected_ref("ROLE or GROUP after IN", self.peek_token_ref()) } } Keyword::ROLE => { if !role.is_empty() { parser_err!("Found multiple ROLE", loc) } else { role = self.parse_comma_separated(|p| p.parse_identifier())?; Ok(()) } } Keyword::USER => { if !user.is_empty() { parser_err!("Found multiple USER", loc) } else { user = self.parse_comma_separated(|p| p.parse_identifier())?; Ok(()) } } Keyword::ADMIN => { if !admin.is_empty() { parser_err!("Found multiple ADMIN", loc) } else { admin = self.parse_comma_separated(|p| p.parse_identifier())?; Ok(()) } } _ => break, }? } Ok(CreateRole { names, if_not_exists, login, inherit, bypassrls, password, create_db, create_role, replication, superuser, connection_limit, valid_until, in_role, in_group, role, user, admin, authorization_owner, }) } /// Parse an `OWNER` clause. pub fn parse_owner(&mut self) -> Result { let owner = match self.parse_one_of_keywords(&[Keyword::CURRENT_USER, Keyword::CURRENT_ROLE, Keyword::SESSION_USER]) { Some(Keyword::CURRENT_USER) => Owner::CurrentUser, Some(Keyword::CURRENT_ROLE) => Owner::CurrentRole, Some(Keyword::SESSION_USER) => Owner::SessionUser, Some(unexpected_keyword) => return Err(ParserError::ParserError( format!("Internal parser error: unexpected keyword `{unexpected_keyword}` in owner"), )), None => { match self.parse_identifier() { Ok(ident) => Owner::Ident(ident), Err(e) => { return Err(ParserError::ParserError(format!("Expected: CURRENT_USER, CURRENT_ROLE, SESSION_USER or identifier after OWNER TO. {e}"))) } } } }; Ok(owner) } /// Parses a [Statement::CreateDomain] statement. fn parse_create_domain(&mut self) -> Result { let name = self.parse_object_name(false)?; self.expect_keyword_is(Keyword::AS)?; let data_type = self.parse_data_type()?; let collation = if self.parse_keyword(Keyword::COLLATE) { Some(self.parse_identifier()?) } else { None }; let default = if self.parse_keyword(Keyword::DEFAULT) { Some(self.parse_expr()?) } else { None }; let mut constraints = Vec::new(); while let Some(constraint) = self.parse_optional_table_constraint()? { constraints.push(constraint); } Ok(CreateDomain { name, data_type, collation, default, constraints, }) } /// ```sql /// CREATE POLICY name ON table_name [ AS { PERMISSIVE | RESTRICTIVE } ] /// [ FOR { ALL | SELECT | INSERT | UPDATE | DELETE } ] /// [ TO { role_name | PUBLIC | CURRENT_USER | CURRENT_ROLE | SESSION_USER } [, ...] ] /// [ USING ( using_expression ) ] /// [ WITH CHECK ( with_check_expression ) ] /// ``` /// /// [PostgreSQL Documentation](https://www.postgresql.org/docs/current/sql-createpolicy.html) pub fn parse_create_policy(&mut self) -> Result { let name = self.parse_identifier()?; self.expect_keyword_is(Keyword::ON)?; let table_name = self.parse_object_name(false)?; let policy_type = if self.parse_keyword(Keyword::AS) { let keyword = self.expect_one_of_keywords(&[Keyword::PERMISSIVE, Keyword::RESTRICTIVE])?; Some(match keyword { Keyword::PERMISSIVE => CreatePolicyType::Permissive, Keyword::RESTRICTIVE => CreatePolicyType::Restrictive, unexpected_keyword => return Err(ParserError::ParserError( format!("Internal parser error: unexpected keyword `{unexpected_keyword}` in policy type"), )), }) } else { None }; let command = if self.parse_keyword(Keyword::FOR) { let keyword = self.expect_one_of_keywords(&[ Keyword::ALL, Keyword::SELECT, Keyword::INSERT, Keyword::UPDATE, Keyword::DELETE, ])?; Some(match keyword { Keyword::ALL => CreatePolicyCommand::All, Keyword::SELECT => CreatePolicyCommand::Select, Keyword::INSERT => CreatePolicyCommand::Insert, Keyword::UPDATE => CreatePolicyCommand::Update, Keyword::DELETE => CreatePolicyCommand::Delete, unexpected_keyword => return Err(ParserError::ParserError( format!("Internal parser error: unexpected keyword `{unexpected_keyword}` in policy command"), )), }) } else { None }; let to = if self.parse_keyword(Keyword::TO) { Some(self.parse_comma_separated(|p| p.parse_owner())?) } else { None }; let using = if self.parse_keyword(Keyword::USING) { self.expect_token(&Token::LParen)?; let expr = self.parse_expr()?; self.expect_token(&Token::RParen)?; Some(expr) } else { None }; let with_check = if self.parse_keywords(&[Keyword::WITH, Keyword::CHECK]) { self.expect_token(&Token::LParen)?; let expr = self.parse_expr()?; self.expect_token(&Token::RParen)?; Some(expr) } else { None }; Ok(CreatePolicy { name, table_name, policy_type, command, to, using, with_check, }) } /// ```sql /// CREATE CONNECTOR [IF NOT EXISTS] connector_name /// [TYPE datasource_type] /// [URL datasource_url] /// [COMMENT connector_comment] /// [WITH DCPROPERTIES(property_name=property_value, ...)] /// ``` /// /// [Hive Documentation](https://cwiki.apache.org/confluence/pages/viewpage.action?pageId=27362034#LanguageManualDDL-CreateDataConnectorCreateConnector) pub fn parse_create_connector(&mut self) -> Result { let if_not_exists = self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]); let name = self.parse_identifier()?; let connector_type = if self.parse_keyword(Keyword::TYPE) { Some(self.parse_literal_string()?) } else { None }; let url = if self.parse_keyword(Keyword::URL) { Some(self.parse_literal_string()?) } else { None }; let comment = self.parse_optional_inline_comment()?; let with_dcproperties = match self.parse_options_with_keywords(&[Keyword::WITH, Keyword::DCPROPERTIES])? { properties if !properties.is_empty() => Some(properties), _ => None, }; Ok(CreateConnector { name, if_not_exists, connector_type, url, comment, with_dcproperties, }) } /// Parse an operator name, which can contain special characters like +, -, <, >, = /// that are tokenized as operator tokens rather than identifiers. /// This is used for PostgreSQL CREATE OPERATOR statements. /// /// Examples: `+`, `myschema.+`, `pg_catalog.<=` fn parse_operator_name(&mut self) -> Result { let mut parts = vec![]; loop { parts.push(ObjectNamePart::Identifier(Ident::new( self.next_token().to_string(), ))); if !self.consume_token(&Token::Period) { break; } } Ok(ObjectName(parts)) } /// Parse a [Statement::CreateOperator] /// /// [PostgreSQL Documentation](https://www.postgresql.org/docs/current/sql-createoperator.html) pub fn parse_create_operator(&mut self) -> Result { let name = self.parse_operator_name()?; self.expect_token(&Token::LParen)?; let mut function: Option = None; let mut is_procedure = false; let mut left_arg: Option = None; let mut right_arg: Option = None; let mut options: Vec = Vec::new(); loop { let keyword = self.expect_one_of_keywords(&[ Keyword::FUNCTION, Keyword::PROCEDURE, Keyword::LEFTARG, Keyword::RIGHTARG, Keyword::COMMUTATOR, Keyword::NEGATOR, Keyword::RESTRICT, Keyword::JOIN, Keyword::HASHES, Keyword::MERGES, ])?; match keyword { Keyword::HASHES if !options.iter().any(|o| matches!(o, OperatorOption::Hashes)) => { options.push(OperatorOption::Hashes); } Keyword::MERGES if !options.iter().any(|o| matches!(o, OperatorOption::Merges)) => { options.push(OperatorOption::Merges); } Keyword::FUNCTION | Keyword::PROCEDURE if function.is_none() => { self.expect_token(&Token::Eq)?; function = Some(self.parse_object_name(false)?); is_procedure = keyword == Keyword::PROCEDURE; } Keyword::LEFTARG if left_arg.is_none() => { self.expect_token(&Token::Eq)?; left_arg = Some(self.parse_data_type()?); } Keyword::RIGHTARG if right_arg.is_none() => { self.expect_token(&Token::Eq)?; right_arg = Some(self.parse_data_type()?); } Keyword::COMMUTATOR if !options .iter() .any(|o| matches!(o, OperatorOption::Commutator(_))) => { self.expect_token(&Token::Eq)?; if self.parse_keyword(Keyword::OPERATOR) { self.expect_token(&Token::LParen)?; let op = self.parse_operator_name()?; self.expect_token(&Token::RParen)?; options.push(OperatorOption::Commutator(op)); } else { options.push(OperatorOption::Commutator(self.parse_operator_name()?)); } } Keyword::NEGATOR if !options .iter() .any(|o| matches!(o, OperatorOption::Negator(_))) => { self.expect_token(&Token::Eq)?; if self.parse_keyword(Keyword::OPERATOR) { self.expect_token(&Token::LParen)?; let op = self.parse_operator_name()?; self.expect_token(&Token::RParen)?; options.push(OperatorOption::Negator(op)); } else { options.push(OperatorOption::Negator(self.parse_operator_name()?)); } } Keyword::RESTRICT if !options .iter() .any(|o| matches!(o, OperatorOption::Restrict(_))) => { self.expect_token(&Token::Eq)?; options.push(OperatorOption::Restrict(Some( self.parse_object_name(false)?, ))); } Keyword::JOIN if !options.iter().any(|o| matches!(o, OperatorOption::Join(_))) => { self.expect_token(&Token::Eq)?; options.push(OperatorOption::Join(Some(self.parse_object_name(false)?))); } _ => { return Err(ParserError::ParserError(format!( "Duplicate or unexpected keyword {:?} in CREATE OPERATOR", keyword ))) } } if !self.consume_token(&Token::Comma) { break; } } // Expect closing parenthesis self.expect_token(&Token::RParen)?; // FUNCTION is required let function = function.ok_or_else(|| { ParserError::ParserError("CREATE OPERATOR requires FUNCTION parameter".to_string()) })?; Ok(CreateOperator { name, function, is_procedure, left_arg, right_arg, options, }) } /// Parse a [Statement::CreateOperatorFamily] /// /// [PostgreSQL Documentation](https://www.postgresql.org/docs/current/sql-createopfamily.html) pub fn parse_create_operator_family(&mut self) -> Result { let name = self.parse_object_name(false)?; self.expect_keyword(Keyword::USING)?; let using = self.parse_identifier()?; Ok(CreateOperatorFamily { name, using }) } /// Parse a [Statement::CreateOperatorClass] /// /// [PostgreSQL Documentation](https://www.postgresql.org/docs/current/sql-createopclass.html) pub fn parse_create_operator_class(&mut self) -> Result { let name = self.parse_object_name(false)?; let default = self.parse_keyword(Keyword::DEFAULT); self.expect_keywords(&[Keyword::FOR, Keyword::TYPE])?; let for_type = self.parse_data_type()?; self.expect_keyword(Keyword::USING)?; let using = self.parse_identifier()?; let family = if self.parse_keyword(Keyword::FAMILY) { Some(self.parse_object_name(false)?) } else { None }; self.expect_keyword(Keyword::AS)?; let mut items = vec![]; loop { if self.parse_keyword(Keyword::OPERATOR) { let strategy_number = self.parse_literal_uint()?; let operator_name = self.parse_operator_name()?; // Optional operator argument types let op_types = if self.consume_token(&Token::LParen) { let left = self.parse_data_type()?; self.expect_token(&Token::Comma)?; let right = self.parse_data_type()?; self.expect_token(&Token::RParen)?; Some(OperatorArgTypes { left, right }) } else { None }; // Optional purpose let purpose = if self.parse_keyword(Keyword::FOR) { if self.parse_keyword(Keyword::SEARCH) { Some(OperatorPurpose::ForSearch) } else if self.parse_keywords(&[Keyword::ORDER, Keyword::BY]) { let sort_family = self.parse_object_name(false)?; Some(OperatorPurpose::ForOrderBy { sort_family }) } else { return self .expected_ref("SEARCH or ORDER BY after FOR", self.peek_token_ref()); } } else { None }; items.push(OperatorClassItem::Operator { strategy_number, operator_name, op_types, purpose, }); } else if self.parse_keyword(Keyword::FUNCTION) { let support_number = self.parse_literal_uint()?; // Optional operator types let op_types = if self.consume_token(&Token::LParen) && self.peek_token_ref().token != Token::RParen { let mut types = vec![]; loop { types.push(self.parse_data_type()?); if !self.consume_token(&Token::Comma) { break; } } self.expect_token(&Token::RParen)?; Some(types) } else if self.consume_token(&Token::LParen) { self.expect_token(&Token::RParen)?; Some(vec![]) } else { None }; let function_name = self.parse_object_name(false)?; // Function argument types let argument_types = if self.consume_token(&Token::LParen) { let mut types = vec![]; loop { if self.peek_token_ref().token == Token::RParen { break; } types.push(self.parse_data_type()?); if !self.consume_token(&Token::Comma) { break; } } self.expect_token(&Token::RParen)?; types } else { vec![] }; items.push(OperatorClassItem::Function { support_number, op_types, function_name, argument_types, }); } else if self.parse_keyword(Keyword::STORAGE) { let storage_type = self.parse_data_type()?; items.push(OperatorClassItem::Storage { storage_type }); } else { break; } // Check for comma separator if !self.consume_token(&Token::Comma) { break; } } Ok(CreateOperatorClass { name, default, for_type, using, family, items, }) } /// Parse a `DROP` statement. pub fn parse_drop(&mut self) -> Result { // MySQL dialect supports `TEMPORARY` let temporary = dialect_of!(self is MySqlDialect | GenericDialect | DuckDbDialect) && self.parse_keyword(Keyword::TEMPORARY); let persistent = dialect_of!(self is DuckDbDialect) && self.parse_one_of_keywords(&[Keyword::PERSISTENT]).is_some(); let object_type = if self.parse_keyword(Keyword::TABLE) { ObjectType::Table } else if self.parse_keyword(Keyword::COLLATION) { ObjectType::Collation } else if self.parse_keyword(Keyword::VIEW) { ObjectType::View } else if self.parse_keywords(&[Keyword::MATERIALIZED, Keyword::VIEW]) { ObjectType::MaterializedView } else if self.parse_keyword(Keyword::INDEX) { ObjectType::Index } else if self.parse_keyword(Keyword::ROLE) { ObjectType::Role } else if self.parse_keyword(Keyword::SCHEMA) { ObjectType::Schema } else if self.parse_keyword(Keyword::DATABASE) { ObjectType::Database } else if self.parse_keyword(Keyword::SEQUENCE) { ObjectType::Sequence } else if self.parse_keyword(Keyword::STAGE) { ObjectType::Stage } else if self.parse_keyword(Keyword::TYPE) { ObjectType::Type } else if self.parse_keyword(Keyword::USER) { ObjectType::User } else if self.parse_keyword(Keyword::STREAM) { ObjectType::Stream } else if self.parse_keyword(Keyword::FUNCTION) { return self.parse_drop_function().map(Into::into); } else if self.parse_keyword(Keyword::POLICY) { return self.parse_drop_policy().map(Into::into); } else if self.parse_keyword(Keyword::CONNECTOR) { return self.parse_drop_connector(); } else if self.parse_keyword(Keyword::DOMAIN) { return self.parse_drop_domain().map(Into::into); } else if self.parse_keyword(Keyword::PROCEDURE) { return self.parse_drop_procedure(); } else if self.parse_keyword(Keyword::SECRET) { return self.parse_drop_secret(temporary, persistent); } else if self.parse_keyword(Keyword::TRIGGER) { return self.parse_drop_trigger().map(Into::into); } else if self.parse_keyword(Keyword::EXTENSION) { return self.parse_drop_extension(); } else if self.parse_keyword(Keyword::OPERATOR) { // Check if this is DROP OPERATOR FAMILY or DROP OPERATOR CLASS return if self.parse_keyword(Keyword::FAMILY) { self.parse_drop_operator_family() } else if self.parse_keyword(Keyword::CLASS) { self.parse_drop_operator_class() } else { self.parse_drop_operator() }; } else { return self.expected_ref( "COLLATION, CONNECTOR, DATABASE, EXTENSION, FUNCTION, INDEX, OPERATOR, POLICY, PROCEDURE, ROLE, SCHEMA, SECRET, SEQUENCE, STAGE, TABLE, TRIGGER, TYPE, VIEW, MATERIALIZED VIEW or USER after DROP", self.peek_token_ref(), ); }; // Many dialects support the non-standard `IF EXISTS` clause and allow // specifying multiple objects to delete in a single statement let if_exists = self.parse_keywords(&[Keyword::IF, Keyword::EXISTS]); let names = self.parse_comma_separated(|p| p.parse_object_name(false))?; let loc = self.peek_token_ref().span.start; let cascade = self.parse_keyword(Keyword::CASCADE); let restrict = self.parse_keyword(Keyword::RESTRICT); let purge = self.parse_keyword(Keyword::PURGE); if cascade && restrict { return parser_err!("Cannot specify both CASCADE and RESTRICT in DROP", loc); } if object_type == ObjectType::Role && (cascade || restrict || purge) { return parser_err!( "Cannot specify CASCADE, RESTRICT, or PURGE in DROP ROLE", loc ); } let table = if self.parse_keyword(Keyword::ON) { Some(self.parse_object_name(false)?) } else { None }; Ok(Statement::Drop { object_type, if_exists, names, cascade, restrict, purge, temporary, table, }) } fn parse_optional_drop_behavior(&mut self) -> Option { match self.parse_one_of_keywords(&[Keyword::CASCADE, Keyword::RESTRICT]) { Some(Keyword::CASCADE) => Some(DropBehavior::Cascade), Some(Keyword::RESTRICT) => Some(DropBehavior::Restrict), _ => None, } } /// ```sql /// DROP FUNCTION [ IF EXISTS ] name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ] [, ...] /// [ CASCADE | RESTRICT ] /// ``` fn parse_drop_function(&mut self) -> Result { let if_exists = self.parse_keywords(&[Keyword::IF, Keyword::EXISTS]); let func_desc = self.parse_comma_separated(Parser::parse_function_desc)?; let drop_behavior = self.parse_optional_drop_behavior(); Ok(DropFunction { if_exists, func_desc, drop_behavior, }) } /// ```sql /// DROP POLICY [ IF EXISTS ] name ON table_name [ CASCADE | RESTRICT ] /// ``` /// /// [PostgreSQL Documentation](https://www.postgresql.org/docs/current/sql-droppolicy.html) fn parse_drop_policy(&mut self) -> Result { let if_exists = self.parse_keywords(&[Keyword::IF, Keyword::EXISTS]); let name = self.parse_identifier()?; self.expect_keyword_is(Keyword::ON)?; let table_name = self.parse_object_name(false)?; let drop_behavior = self.parse_optional_drop_behavior(); Ok(DropPolicy { if_exists, name, table_name, drop_behavior, }) } /// ```sql /// DROP CONNECTOR [IF EXISTS] name /// ``` /// /// See [Hive](https://cwiki.apache.org/confluence/pages/viewpage.action?pageId=27362034#LanguageManualDDL-DropConnector) fn parse_drop_connector(&mut self) -> Result { let if_exists = self.parse_keywords(&[Keyword::IF, Keyword::EXISTS]); let name = self.parse_identifier()?; Ok(Statement::DropConnector { if_exists, name }) } /// ```sql /// DROP DOMAIN [ IF EXISTS ] name [ CASCADE | RESTRICT ] /// ``` fn parse_drop_domain(&mut self) -> Result { let if_exists = self.parse_keywords(&[Keyword::IF, Keyword::EXISTS]); let name = self.parse_object_name(false)?; let drop_behavior = self.parse_optional_drop_behavior(); Ok(DropDomain { if_exists, name, drop_behavior, }) } /// ```sql /// DROP PROCEDURE [ IF EXISTS ] name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ] [, ...] /// [ CASCADE | RESTRICT ] /// ``` fn parse_drop_procedure(&mut self) -> Result { let if_exists = self.parse_keywords(&[Keyword::IF, Keyword::EXISTS]); let proc_desc = self.parse_comma_separated(Parser::parse_function_desc)?; let drop_behavior = self.parse_optional_drop_behavior(); Ok(Statement::DropProcedure { if_exists, proc_desc, drop_behavior, }) } fn parse_function_desc(&mut self) -> Result { let name = self.parse_object_name(false)?; let args = if self.consume_token(&Token::LParen) { if self.consume_token(&Token::RParen) { Some(vec![]) } else { let args = self.parse_comma_separated(Parser::parse_function_arg)?; self.expect_token(&Token::RParen)?; Some(args) } } else { None }; Ok(FunctionDesc { name, args }) } /// See [DuckDB Docs](https://duckdb.org/docs/sql/statements/create_secret.html) for more details. fn parse_drop_secret( &mut self, temporary: bool, persistent: bool, ) -> Result { let if_exists = self.parse_keywords(&[Keyword::IF, Keyword::EXISTS]); let name = self.parse_identifier()?; let storage_specifier = if self.parse_keyword(Keyword::FROM) { self.parse_identifier().ok() } else { None }; let temp = match (temporary, persistent) { (true, false) => Some(true), (false, true) => Some(false), (false, false) => None, _ => self.expected_ref("TEMPORARY or PERSISTENT", self.peek_token_ref())?, }; Ok(Statement::DropSecret { if_exists, temporary: temp, name, storage_specifier, }) } /// Parse a `DECLARE` statement. /// /// ```sql /// DECLARE name [ BINARY ] [ ASENSITIVE | INSENSITIVE ] [ [ NO ] SCROLL ] /// CURSOR [ { WITH | WITHOUT } HOLD ] FOR query /// ``` /// /// The syntax can vary significantly between warehouses. See the grammar /// on the warehouse specific function in such cases. pub fn parse_declare(&mut self) -> Result { if dialect_of!(self is BigQueryDialect) { return self.parse_big_query_declare(); } if dialect_of!(self is SnowflakeDialect) { return self.parse_snowflake_declare(); } if dialect_of!(self is MsSqlDialect) { return self.parse_mssql_declare(); } let name = self.parse_identifier()?; let binary = Some(self.parse_keyword(Keyword::BINARY)); let sensitive = if self.parse_keyword(Keyword::INSENSITIVE) { Some(true) } else if self.parse_keyword(Keyword::ASENSITIVE) { Some(false) } else { None }; let scroll = if self.parse_keyword(Keyword::SCROLL) { Some(true) } else if self.parse_keywords(&[Keyword::NO, Keyword::SCROLL]) { Some(false) } else { None }; self.expect_keyword_is(Keyword::CURSOR)?; let declare_type = Some(DeclareType::Cursor); let hold = match self.parse_one_of_keywords(&[Keyword::WITH, Keyword::WITHOUT]) { Some(keyword) => { self.expect_keyword_is(Keyword::HOLD)?; match keyword { Keyword::WITH => Some(true), Keyword::WITHOUT => Some(false), unexpected_keyword => return Err(ParserError::ParserError( format!("Internal parser error: unexpected keyword `{unexpected_keyword}` in cursor hold"), )), } } None => None, }; self.expect_keyword_is(Keyword::FOR)?; let query = Some(self.parse_query()?); Ok(Statement::Declare { stmts: vec![Declare { names: vec![name], data_type: None, assignment: None, declare_type, binary, sensitive, scroll, hold, for_query: query, }], }) } /// Parse a [BigQuery] `DECLARE` statement. /// /// Syntax: /// ```text /// DECLARE variable_name[, ...] [{ | }]; /// ``` /// [BigQuery]: https://cloud.google.com/bigquery/docs/reference/standard-sql/procedural-language#declare pub fn parse_big_query_declare(&mut self) -> Result { let names = self.parse_comma_separated(Parser::parse_identifier)?; let data_type = match &self.peek_token_ref().token { Token::Word(w) if w.keyword == Keyword::DEFAULT => None, _ => Some(self.parse_data_type()?), }; let expr = if data_type.is_some() { if self.parse_keyword(Keyword::DEFAULT) { Some(self.parse_expr()?) } else { None } } else { // If no variable type - default expression must be specified, per BQ docs. // i.e `DECLARE foo;` is invalid. self.expect_keyword_is(Keyword::DEFAULT)?; Some(self.parse_expr()?) }; Ok(Statement::Declare { stmts: vec![Declare { names, data_type, assignment: expr.map(|expr| DeclareAssignment::Default(Box::new(expr))), declare_type: None, binary: None, sensitive: None, scroll: None, hold: None, for_query: None, }], }) } /// Parse a [Snowflake] `DECLARE` statement. /// /// Syntax: /// ```text /// DECLARE /// [{ /// | /// | /// | }; ... ] /// /// /// [] [ { DEFAULT | := } ] /// /// /// CURSOR FOR /// /// /// RESULTSET [ { DEFAULT | := } ( ) ] ; /// /// /// EXCEPTION [ ( , '' ) ] ; /// ``` /// /// [Snowflake]: https://docs.snowflake.com/en/sql-reference/snowflake-scripting/declare pub fn parse_snowflake_declare(&mut self) -> Result { let mut stmts = vec![]; loop { let name = self.parse_identifier()?; let (declare_type, for_query, assigned_expr, data_type) = if self.parse_keyword(Keyword::CURSOR) { self.expect_keyword_is(Keyword::FOR)?; match &self.peek_token_ref().token { Token::Word(w) if w.keyword == Keyword::SELECT => ( Some(DeclareType::Cursor), Some(self.parse_query()?), None, None, ), _ => ( Some(DeclareType::Cursor), None, Some(DeclareAssignment::For(Box::new(self.parse_expr()?))), None, ), } } else if self.parse_keyword(Keyword::RESULTSET) { let assigned_expr = if self.peek_token_ref().token != Token::SemiColon { self.parse_snowflake_variable_declaration_expression()? } else { // Nothing more to do. The statement has no further parameters. None }; (Some(DeclareType::ResultSet), None, assigned_expr, None) } else if self.parse_keyword(Keyword::EXCEPTION) { let assigned_expr = if self.peek_token_ref().token == Token::LParen { Some(DeclareAssignment::Expr(Box::new(self.parse_expr()?))) } else { // Nothing more to do. The statement has no further parameters. None }; (Some(DeclareType::Exception), None, assigned_expr, None) } else { // Without an explicit keyword, the only valid option is variable declaration. let (assigned_expr, data_type) = if let Some(assigned_expr) = self.parse_snowflake_variable_declaration_expression()? { (Some(assigned_expr), None) } else if let Token::Word(_) = &self.peek_token_ref().token { let data_type = self.parse_data_type()?; ( self.parse_snowflake_variable_declaration_expression()?, Some(data_type), ) } else { (None, None) }; (None, None, assigned_expr, data_type) }; let stmt = Declare { names: vec![name], data_type, assignment: assigned_expr, declare_type, binary: None, sensitive: None, scroll: None, hold: None, for_query, }; stmts.push(stmt); if self.consume_token(&Token::SemiColon) { match &self.peek_token_ref().token { Token::Word(w) if ALL_KEYWORDS .binary_search(&w.value.to_uppercase().as_str()) .is_err() => { // Not a keyword - start of a new declaration. continue; } _ => { // Put back the semicolon, this is the end of the DECLARE statement. self.prev_token(); } } } break; } Ok(Statement::Declare { stmts }) } /// Parse a [MsSql] `DECLARE` statement. /// /// Syntax: /// ```text /// DECLARE // { // { @local_variable [AS] data_type [ = value ] } // | { @cursor_variable_name CURSOR [ FOR ] } // } [ ,...n ] /// ``` /// [MsSql]: https://learn.microsoft.com/en-us/sql/t-sql/language-elements/declare-local-variable-transact-sql?view=sql-server-ver16 pub fn parse_mssql_declare(&mut self) -> Result { let stmts = self.parse_comma_separated(Parser::parse_mssql_declare_stmt)?; Ok(Statement::Declare { stmts }) } /// Parse the body of a [MsSql] `DECLARE`statement. /// /// Syntax: /// ```text // { // { @local_variable [AS] data_type [ = value ] } // | { @cursor_variable_name CURSOR [ FOR ]} // } [ ,...n ] /// ``` /// [MsSql]: https://learn.microsoft.com/en-us/sql/t-sql/language-elements/declare-local-variable-transact-sql?view=sql-server-ver16 pub fn parse_mssql_declare_stmt(&mut self) -> Result { let name = { let ident = self.parse_identifier()?; if !ident.value.starts_with('@') && !matches!( &self.peek_token_ref().token, Token::Word(w) if w.keyword == Keyword::CURSOR ) { Err(ParserError::TokenizerError( "Invalid MsSql variable declaration.".to_string(), )) } else { Ok(ident) } }?; let (declare_type, data_type) = match &self.peek_token_ref().token { Token::Word(w) => match w.keyword { Keyword::CURSOR => { self.next_token(); (Some(DeclareType::Cursor), None) } Keyword::AS => { self.next_token(); (None, Some(self.parse_data_type()?)) } _ => (None, Some(self.parse_data_type()?)), }, _ => (None, Some(self.parse_data_type()?)), }; let (for_query, assignment) = if self.peek_keyword(Keyword::FOR) { self.next_token(); let query = Some(self.parse_query()?); (query, None) } else { let assignment = self.parse_mssql_variable_declaration_expression()?; (None, assignment) }; Ok(Declare { names: vec![name], data_type, assignment, declare_type, binary: None, sensitive: None, scroll: None, hold: None, for_query, }) } /// Parses the assigned expression in a variable declaration. /// /// Syntax: /// ```text /// [ { DEFAULT | := } ] /// ``` /// pub fn parse_snowflake_variable_declaration_expression( &mut self, ) -> Result, ParserError> { Ok(match &self.peek_token_ref().token { Token::Word(w) if w.keyword == Keyword::DEFAULT => { self.next_token(); // Skip `DEFAULT` Some(DeclareAssignment::Default(Box::new(self.parse_expr()?))) } Token::Assignment => { self.next_token(); // Skip `:=` Some(DeclareAssignment::DuckAssignment(Box::new( self.parse_expr()?, ))) } _ => None, }) } /// Parses the assigned expression in a variable declaration. /// /// Syntax: /// ```text /// [ = ] /// ``` pub fn parse_mssql_variable_declaration_expression( &mut self, ) -> Result, ParserError> { Ok(match &self.peek_token_ref().token { Token::Eq => { self.next_token(); // Skip `=` Some(DeclareAssignment::MsSqlAssignment(Box::new( self.parse_expr()?, ))) } _ => None, }) } /// Parse `FETCH [direction] { FROM | IN } cursor INTO target;` statement. pub fn parse_fetch_statement(&mut self) -> Result { let direction = if self.parse_keyword(Keyword::NEXT) { FetchDirection::Next } else if self.parse_keyword(Keyword::PRIOR) { FetchDirection::Prior } else if self.parse_keyword(Keyword::FIRST) { FetchDirection::First } else if self.parse_keyword(Keyword::LAST) { FetchDirection::Last } else if self.parse_keyword(Keyword::ABSOLUTE) { FetchDirection::Absolute { limit: self.parse_number_value()?, } } else if self.parse_keyword(Keyword::RELATIVE) { FetchDirection::Relative { limit: self.parse_number_value()?, } } else if self.parse_keyword(Keyword::FORWARD) { if self.parse_keyword(Keyword::ALL) { FetchDirection::ForwardAll } else { FetchDirection::Forward { // TODO: Support optional limit: Some(self.parse_number_value()?), } } } else if self.parse_keyword(Keyword::BACKWARD) { if self.parse_keyword(Keyword::ALL) { FetchDirection::BackwardAll } else { FetchDirection::Backward { // TODO: Support optional limit: Some(self.parse_number_value()?), } } } else if self.parse_keyword(Keyword::ALL) { FetchDirection::All } else { FetchDirection::Count { limit: self.parse_number_value()?, } }; let position = if self.peek_keyword(Keyword::FROM) { self.expect_keyword(Keyword::FROM)?; FetchPosition::From } else if self.peek_keyword(Keyword::IN) { self.expect_keyword(Keyword::IN)?; FetchPosition::In } else { return parser_err!("Expected FROM or IN", self.peek_token_ref().span.start); }; let name = self.parse_identifier()?; let into = if self.parse_keyword(Keyword::INTO) { Some(self.parse_object_name(false)?) } else { None }; Ok(Statement::Fetch { name, direction, position, into, }) } /// Parse a `DISCARD` statement. pub fn parse_discard(&mut self) -> Result { let object_type = if self.parse_keyword(Keyword::ALL) { DiscardObject::ALL } else if self.parse_keyword(Keyword::PLANS) { DiscardObject::PLANS } else if self.parse_keyword(Keyword::SEQUENCES) { DiscardObject::SEQUENCES } else if self.parse_keyword(Keyword::TEMP) || self.parse_keyword(Keyword::TEMPORARY) { DiscardObject::TEMP } else { return self.expected_ref( "ALL, PLANS, SEQUENCES, TEMP or TEMPORARY after DISCARD", self.peek_token_ref(), ); }; Ok(Statement::Discard { object_type }) } /// Parse a `CREATE INDEX` statement. pub fn parse_create_index(&mut self, unique: bool) -> Result { let concurrently = self.parse_keyword(Keyword::CONCURRENTLY); let if_not_exists = self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]); let mut using = None; let index_name = if if_not_exists || !self.parse_keyword(Keyword::ON) { let index_name = self.parse_object_name(false)?; // MySQL allows `USING index_type` either before or after `ON table_name` using = self.parse_optional_using_then_index_type()?; self.expect_keyword_is(Keyword::ON)?; Some(index_name) } else { None }; let table_name = self.parse_object_name(false)?; // MySQL allows having two `USING` clauses. // In that case, the second clause overwrites the first. using = self.parse_optional_using_then_index_type()?.or(using); let columns = self.parse_parenthesized_index_column_list()?; let include = if self.parse_keyword(Keyword::INCLUDE) { self.expect_token(&Token::LParen)?; let columns = self.parse_comma_separated(|p| p.parse_identifier())?; self.expect_token(&Token::RParen)?; columns } else { vec![] }; let nulls_distinct = if self.parse_keyword(Keyword::NULLS) { let not = self.parse_keyword(Keyword::NOT); self.expect_keyword_is(Keyword::DISTINCT)?; Some(!not) } else { None }; let with = if self.dialect.supports_create_index_with_clause() && self.parse_keyword(Keyword::WITH) { self.expect_token(&Token::LParen)?; let with_params = self.parse_comma_separated(Parser::parse_expr)?; self.expect_token(&Token::RParen)?; with_params } else { Vec::new() }; let predicate = if self.parse_keyword(Keyword::WHERE) { Some(self.parse_expr()?) } else { None }; // MySQL options (including the modern style of `USING` after the column list instead of // before, which is deprecated) shouldn't conflict with other preceding options (e.g. `WITH // PARSER` won't be caught by the above `WITH` clause parsing because MySQL doesn't set that // support flag). This is probably invalid syntax for other dialects, but it is simpler to // parse it anyway (as we do inside `ALTER TABLE` and `CREATE TABLE` parsing). let index_options = self.parse_index_options()?; // MySQL allows `ALGORITHM` and `LOCK` options. Unlike in `ALTER TABLE`, they need not be comma separated. let mut alter_options = Vec::new(); while self .peek_one_of_keywords(&[Keyword::ALGORITHM, Keyword::LOCK]) .is_some() { alter_options.push(self.parse_alter_table_operation()?) } Ok(CreateIndex { name: index_name, table_name, using, columns, unique, concurrently, if_not_exists, include, nulls_distinct, with, predicate, index_options, alter_options, }) } /// Parse a `CREATE EXTENSION` statement. pub fn parse_create_extension(&mut self) -> Result { let if_not_exists = self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]); let name = self.parse_identifier()?; let (schema, version, cascade) = if self.parse_keyword(Keyword::WITH) { let schema = if self.parse_keyword(Keyword::SCHEMA) { Some(self.parse_identifier()?) } else { None }; let version = if self.parse_keyword(Keyword::VERSION) { Some(self.parse_identifier()?) } else { None }; let cascade = self.parse_keyword(Keyword::CASCADE); (schema, version, cascade) } else { (None, None, false) }; Ok(CreateExtension { name, if_not_exists, schema, version, cascade, }) } /// Parse a PostgreSQL-specific [Statement::CreateCollation] statement. pub fn parse_create_collation(&mut self) -> Result { let if_not_exists = self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]); let name = self.parse_object_name(false)?; let definition = if self.parse_keyword(Keyword::FROM) { CreateCollationDefinition::From(self.parse_object_name(false)?) } else if self.consume_token(&Token::LParen) { let options = self.parse_comma_separated(Parser::parse_sql_option)?; self.expect_token(&Token::RParen)?; CreateCollationDefinition::Options(options) } else { return self.expected_ref( "FROM or parenthesized option list after CREATE COLLATION name", self.peek_token_ref(), ); }; Ok(CreateCollation { if_not_exists, name, definition, }) } /// Parse a PostgreSQL-specific [Statement::DropExtension] statement. pub fn parse_drop_extension(&mut self) -> Result { let if_exists = self.parse_keywords(&[Keyword::IF, Keyword::EXISTS]); let names = self.parse_comma_separated(|p| p.parse_identifier())?; let cascade_or_restrict = self.parse_one_of_keywords(&[Keyword::CASCADE, Keyword::RESTRICT]); Ok(Statement::DropExtension(DropExtension { names, if_exists, cascade_or_restrict: cascade_or_restrict .map(|k| match k { Keyword::CASCADE => Ok(ReferentialAction::Cascade), Keyword::RESTRICT => Ok(ReferentialAction::Restrict), _ => self.expected_ref("CASCADE or RESTRICT", self.peek_token_ref()), }) .transpose()?, })) } /// Parse a[Statement::DropOperator] statement. /// pub fn parse_drop_operator(&mut self) -> Result { let if_exists = self.parse_keywords(&[Keyword::IF, Keyword::EXISTS]); let operators = self.parse_comma_separated(|p| p.parse_drop_operator_signature())?; let drop_behavior = self.parse_optional_drop_behavior(); Ok(Statement::DropOperator(DropOperator { if_exists, operators, drop_behavior, })) } /// Parse an operator signature for a [Statement::DropOperator] /// Format: `name ( { left_type | NONE } , right_type )` fn parse_drop_operator_signature(&mut self) -> Result { let name = self.parse_operator_name()?; self.expect_token(&Token::LParen)?; // Parse left operand type (or NONE for prefix operators) let left_type = if self.parse_keyword(Keyword::NONE) { None } else { Some(self.parse_data_type()?) }; self.expect_token(&Token::Comma)?; // Parse right operand type (always required) let right_type = self.parse_data_type()?; self.expect_token(&Token::RParen)?; Ok(DropOperatorSignature { name, left_type, right_type, }) } /// Parse a [Statement::DropOperatorFamily] /// /// [PostgreSQL Documentation](https://www.postgresql.org/docs/current/sql-dropopfamily.html) pub fn parse_drop_operator_family(&mut self) -> Result { let if_exists = self.parse_keywords(&[Keyword::IF, Keyword::EXISTS]); let names = self.parse_comma_separated(|p| p.parse_object_name(false))?; self.expect_keyword(Keyword::USING)?; let using = self.parse_identifier()?; let drop_behavior = self.parse_optional_drop_behavior(); Ok(Statement::DropOperatorFamily(DropOperatorFamily { if_exists, names, using, drop_behavior, })) } /// Parse a [Statement::DropOperatorClass] /// /// [PostgreSQL Documentation](https://www.postgresql.org/docs/current/sql-dropopclass.html) pub fn parse_drop_operator_class(&mut self) -> Result { let if_exists = self.parse_keywords(&[Keyword::IF, Keyword::EXISTS]); let names = self.parse_comma_separated(|p| p.parse_object_name(false))?; self.expect_keyword(Keyword::USING)?; let using = self.parse_identifier()?; let drop_behavior = self.parse_optional_drop_behavior(); Ok(Statement::DropOperatorClass(DropOperatorClass { if_exists, names, using, drop_behavior, })) } /// Parse Hive distribution style. /// /// TODO: Support parsing for `SKEWED` distribution style. pub fn parse_hive_distribution(&mut self) -> Result { if self.parse_keywords(&[Keyword::PARTITIONED, Keyword::BY]) { self.expect_token(&Token::LParen)?; let columns = self.parse_comma_separated(|parser| parser.parse_column_def_inner(true))?; self.expect_token(&Token::RParen)?; Ok(HiveDistributionStyle::PARTITIONED { columns }) } else { Ok(HiveDistributionStyle::NONE) } } /// Parse Redshift `DISTSTYLE { AUTO | EVEN | KEY | ALL }`. /// /// See fn parse_dist_style(&mut self) -> Result { let token = self.next_token(); match &token.token { Token::Word(w) => match w.keyword { Keyword::AUTO => Ok(DistStyle::Auto), Keyword::EVEN => Ok(DistStyle::Even), Keyword::KEY => Ok(DistStyle::Key), Keyword::ALL => Ok(DistStyle::All), _ => self.expected("AUTO, EVEN, KEY, or ALL", token), }, _ => self.expected("AUTO, EVEN, KEY, or ALL", token), } } /// Parse Hive formats. pub fn parse_hive_formats(&mut self) -> Result, ParserError> { let mut hive_format: Option = None; loop { match self.parse_one_of_keywords(&[ Keyword::ROW, Keyword::STORED, Keyword::LOCATION, Keyword::WITH, Keyword::USING, ]) { Some(Keyword::ROW) => { hive_format .get_or_insert_with(HiveFormat::default) .row_format = Some(self.parse_row_format()?); } Some(Keyword::STORED) => { self.expect_keyword_is(Keyword::AS)?; if self.parse_keyword(Keyword::INPUTFORMAT) { let input_format = self.parse_expr()?; self.expect_keyword_is(Keyword::OUTPUTFORMAT)?; let output_format = self.parse_expr()?; hive_format.get_or_insert_with(HiveFormat::default).storage = Some(HiveIOFormat::IOF { input_format, output_format, }); } else { let format = self.parse_file_format()?; hive_format.get_or_insert_with(HiveFormat::default).storage = Some(HiveIOFormat::FileFormat { format }); } } Some(Keyword::LOCATION) => { hive_format.get_or_insert_with(HiveFormat::default).location = Some(self.parse_literal_string()?); } Some(Keyword::WITH) => { self.prev_token(); let properties = self .parse_options_with_keywords(&[Keyword::WITH, Keyword::SERDEPROPERTIES])?; if !properties.is_empty() { hive_format .get_or_insert_with(HiveFormat::default) .serde_properties = Some(properties); } else { break; } } Some(Keyword::USING) if self.dialect.supports_create_table_using() => { let format = self.parse_identifier()?; hive_format.get_or_insert_with(HiveFormat::default).storage = Some(HiveIOFormat::Using { format }); } Some(Keyword::USING) => { // USING is not a table format keyword in this dialect; put it back self.prev_token(); break; } None => break, _ => break, } } Ok(hive_format) } /// Parse Hive row format. pub fn parse_row_format(&mut self) -> Result { self.expect_keyword_is(Keyword::FORMAT)?; match self.parse_one_of_keywords(&[Keyword::SERDE, Keyword::DELIMITED]) { Some(Keyword::SERDE) => { let class = self.parse_literal_string()?; Ok(HiveRowFormat::SERDE { class }) } _ => { let mut row_delimiters = vec![]; loop { match self.parse_one_of_keywords(&[ Keyword::FIELDS, Keyword::COLLECTION, Keyword::MAP, Keyword::LINES, Keyword::NULL, ]) { Some(Keyword::FIELDS) if self.parse_keywords(&[Keyword::TERMINATED, Keyword::BY]) => { row_delimiters.push(HiveRowDelimiter { delimiter: HiveDelimiter::FieldsTerminatedBy, char: self.parse_identifier()?, }); if self.parse_keywords(&[Keyword::ESCAPED, Keyword::BY]) { row_delimiters.push(HiveRowDelimiter { delimiter: HiveDelimiter::FieldsEscapedBy, char: self.parse_identifier()?, }); } } Some(Keyword::COLLECTION) if self.parse_keywords(&[ Keyword::ITEMS, Keyword::TERMINATED, Keyword::BY, ]) => { row_delimiters.push(HiveRowDelimiter { delimiter: HiveDelimiter::CollectionItemsTerminatedBy, char: self.parse_identifier()?, }); } Some(Keyword::MAP) if self.parse_keywords(&[ Keyword::KEYS, Keyword::TERMINATED, Keyword::BY, ]) => { row_delimiters.push(HiveRowDelimiter { delimiter: HiveDelimiter::MapKeysTerminatedBy, char: self.parse_identifier()?, }); } Some(Keyword::LINES) if self.parse_keywords(&[Keyword::TERMINATED, Keyword::BY]) => { row_delimiters.push(HiveRowDelimiter { delimiter: HiveDelimiter::LinesTerminatedBy, char: self.parse_identifier()?, }); } Some(Keyword::NULL) if self.parse_keywords(&[Keyword::DEFINED, Keyword::AS]) => { row_delimiters.push(HiveRowDelimiter { delimiter: HiveDelimiter::NullDefinedAs, char: self.parse_identifier()?, }); } _ => { break; } } } Ok(HiveRowFormat::DELIMITED { delimiters: row_delimiters, }) } } } fn parse_optional_on_cluster(&mut self) -> Result, ParserError> { if self.parse_keywords(&[Keyword::ON, Keyword::CLUSTER]) { Ok(Some(self.parse_identifier()?)) } else { Ok(None) } } /// Parse `CREATE TABLE` statement. pub fn parse_create_table( &mut self, or_replace: bool, temporary: bool, global: Option, transient: bool, ) -> Result { let allow_unquoted_hyphen = dialect_of!(self is BigQueryDialect); let if_not_exists = self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]); let table_name = self.parse_object_name(allow_unquoted_hyphen)?; // PostgreSQL PARTITION OF for child partition tables // Note: This is a PostgreSQL-specific feature, but the dialect check was intentionally // removed to allow GenericDialect and other dialects to parse this syntax. This enables // multi-dialect SQL tools to work with PostgreSQL-specific DDL statements. // // PARTITION OF can be combined with other table definition clauses in the AST, // though PostgreSQL itself prohibits PARTITION OF with AS SELECT or LIKE clauses. // The parser accepts these combinations for flexibility; semantic validation // is left to downstream tools. // Child partitions can have their own constraints and indexes. let partition_of = if self.parse_keywords(&[Keyword::PARTITION, Keyword::OF]) { Some(self.parse_object_name(allow_unquoted_hyphen)?) } else { None }; // Clickhouse has `ON CLUSTER 'cluster'` syntax for DDLs let on_cluster = self.parse_optional_on_cluster()?; let like = self.maybe_parse_create_table_like(allow_unquoted_hyphen)?; let clone = if self.parse_keyword(Keyword::CLONE) { self.parse_object_name(allow_unquoted_hyphen).ok() } else { None }; // parse optional column list (schema) let (columns, constraints) = self.parse_columns()?; let comment_after_column_def = if dialect_of!(self is HiveDialect) && self.parse_keyword(Keyword::COMMENT) { let next_token = self.next_token(); match next_token.token { Token::SingleQuotedString(str) => Some(CommentDef::WithoutEq(str)), _ => self.expected("comment", next_token)?, } } else { None }; // PostgreSQL PARTITION OF: partition bound specification let for_values = if partition_of.is_some() { if self.peek_keyword(Keyword::FOR) || self.peek_keyword(Keyword::DEFAULT) { Some(self.parse_partition_for_values()?) } else { return self.expected_ref( "FOR VALUES or DEFAULT after PARTITION OF", self.peek_token_ref(), ); } } else { None }; // SQLite supports `WITHOUT ROWID` at the end of `CREATE TABLE` let without_rowid = self.parse_keywords(&[Keyword::WITHOUT, Keyword::ROWID]); let hive_distribution = self.parse_hive_distribution()?; let clustered_by = self.parse_optional_clustered_by()?; let hive_formats = self.parse_hive_formats()?; let create_table_config = self.parse_optional_create_table_config()?; // ClickHouse supports `PRIMARY KEY`, before `ORDER BY` // https://clickhouse.com/docs/en/sql-reference/statements/create/table#primary-key let primary_key = if dialect_of!(self is ClickHouseDialect | GenericDialect) && self.parse_keywords(&[Keyword::PRIMARY, Keyword::KEY]) { Some(Box::new(self.parse_expr()?)) } else { None }; let order_by = if self.parse_keywords(&[Keyword::ORDER, Keyword::BY]) { if self.consume_token(&Token::LParen) { let columns = if self.peek_token_ref().token != Token::RParen { self.parse_comma_separated(|p| p.parse_expr())? } else { vec![] }; self.expect_token(&Token::RParen)?; Some(OneOrManyWithParens::Many(columns)) } else { Some(OneOrManyWithParens::One(self.parse_expr()?)) } } else { None }; // ClickHouse allows PARTITION BY after ORDER BY // https://clickhouse.com/docs/en/sql-reference/statements/create/table#partition-by let partition_by = if create_table_config.partition_by.is_none() && self.dialect.supports_partition_by_after_order_by() && self.parse_keywords(&[Keyword::PARTITION, Keyword::BY]) { Some(Box::new(self.parse_expr()?)) } else { create_table_config.partition_by }; let on_commit = if self.parse_keywords(&[Keyword::ON, Keyword::COMMIT]) { Some(self.parse_create_table_on_commit()?) } else { None }; let strict = self.parse_keyword(Keyword::STRICT); // Redshift: BACKUP YES|NO let backup = if self.parse_keyword(Keyword::BACKUP) { let keyword = self.expect_one_of_keywords(&[Keyword::YES, Keyword::NO])?; Some(keyword == Keyword::YES) } else { None }; // Redshift: DISTSTYLE, DISTKEY, SORTKEY let diststyle = if self.parse_keyword(Keyword::DISTSTYLE) { Some(self.parse_dist_style()?) } else { None }; let distkey = if self.parse_keyword(Keyword::DISTKEY) { self.expect_token(&Token::LParen)?; let expr = self.parse_expr()?; self.expect_token(&Token::RParen)?; Some(expr) } else { None }; let sortkey = if self.parse_keyword(Keyword::SORTKEY) { self.expect_token(&Token::LParen)?; let columns = self.parse_comma_separated(|p| p.parse_expr())?; self.expect_token(&Token::RParen)?; Some(columns) } else { None }; // Parse optional `AS ( query )` let query = if self.parse_keyword(Keyword::AS) { Some(self.parse_query()?) } else if self.dialect.supports_create_table_select() && self.parse_keyword(Keyword::SELECT) { // rewind the SELECT keyword self.prev_token(); Some(self.parse_query()?) } else { None }; Ok(CreateTableBuilder::new(table_name) .temporary(temporary) .columns(columns) .constraints(constraints) .or_replace(or_replace) .if_not_exists(if_not_exists) .transient(transient) .hive_distribution(hive_distribution) .hive_formats(hive_formats) .global(global) .query(query) .without_rowid(without_rowid) .like(like) .clone_clause(clone) .comment_after_column_def(comment_after_column_def) .order_by(order_by) .on_commit(on_commit) .on_cluster(on_cluster) .clustered_by(clustered_by) .partition_by(partition_by) .cluster_by(create_table_config.cluster_by) .inherits(create_table_config.inherits) .partition_of(partition_of) .for_values(for_values) .table_options(create_table_config.table_options) .primary_key(primary_key) .strict(strict) .backup(backup) .diststyle(diststyle) .distkey(distkey) .sortkey(sortkey) .build()) } fn maybe_parse_create_table_like( &mut self, allow_unquoted_hyphen: bool, ) -> Result, ParserError> { let like = if self.dialect.supports_create_table_like_parenthesized() && self.consume_token(&Token::LParen) { if self.parse_keyword(Keyword::LIKE) { let name = self.parse_object_name(allow_unquoted_hyphen)?; let defaults = if self.parse_keywords(&[Keyword::INCLUDING, Keyword::DEFAULTS]) { Some(CreateTableLikeDefaults::Including) } else if self.parse_keywords(&[Keyword::EXCLUDING, Keyword::DEFAULTS]) { Some(CreateTableLikeDefaults::Excluding) } else { None }; self.expect_token(&Token::RParen)?; Some(CreateTableLikeKind::Parenthesized(CreateTableLike { name, defaults, })) } else { // Rollback the '(' it's probably the columns list self.prev_token(); None } } else if self.parse_keyword(Keyword::LIKE) || self.parse_keyword(Keyword::ILIKE) { let name = self.parse_object_name(allow_unquoted_hyphen)?; Some(CreateTableLikeKind::Plain(CreateTableLike { name, defaults: None, })) } else { None }; Ok(like) } pub(crate) fn parse_create_table_on_commit(&mut self) -> Result { if self.parse_keywords(&[Keyword::DELETE, Keyword::ROWS]) { Ok(OnCommit::DeleteRows) } else if self.parse_keywords(&[Keyword::PRESERVE, Keyword::ROWS]) { Ok(OnCommit::PreserveRows) } else if self.parse_keywords(&[Keyword::DROP]) { Ok(OnCommit::Drop) } else { parser_err!( "Expecting DELETE ROWS, PRESERVE ROWS or DROP", self.peek_token_ref() ) } } /// Parse [ForValues] of a `PARTITION OF` clause. /// /// Parses: `FOR VALUES partition_bound_spec | DEFAULT` /// /// [PostgreSQL](https://www.postgresql.org/docs/current/sql-createtable.html) fn parse_partition_for_values(&mut self) -> Result { if self.parse_keyword(Keyword::DEFAULT) { return Ok(ForValues::Default); } self.expect_keywords(&[Keyword::FOR, Keyword::VALUES])?; if self.parse_keyword(Keyword::IN) { // FOR VALUES IN (expr, ...) self.expect_token(&Token::LParen)?; if self.peek_token_ref().token == Token::RParen { return self.expected_ref("at least one value", self.peek_token_ref()); } let values = self.parse_comma_separated(Parser::parse_expr)?; self.expect_token(&Token::RParen)?; Ok(ForValues::In(values)) } else if self.parse_keyword(Keyword::FROM) { // FOR VALUES FROM (...) TO (...) self.expect_token(&Token::LParen)?; if self.peek_token_ref().token == Token::RParen { return self.expected_ref("at least one value", self.peek_token_ref()); } let from = self.parse_comma_separated(Parser::parse_partition_bound_value)?; self.expect_token(&Token::RParen)?; self.expect_keyword(Keyword::TO)?; self.expect_token(&Token::LParen)?; if self.peek_token_ref().token == Token::RParen { return self.expected_ref("at least one value", self.peek_token_ref()); } let to = self.parse_comma_separated(Parser::parse_partition_bound_value)?; self.expect_token(&Token::RParen)?; Ok(ForValues::From { from, to }) } else if self.parse_keyword(Keyword::WITH) { // FOR VALUES WITH (MODULUS n, REMAINDER r) self.expect_token(&Token::LParen)?; self.expect_keyword(Keyword::MODULUS)?; let modulus = self.parse_literal_uint()?; self.expect_token(&Token::Comma)?; self.expect_keyword(Keyword::REMAINDER)?; let remainder = self.parse_literal_uint()?; self.expect_token(&Token::RParen)?; Ok(ForValues::With { modulus, remainder }) } else { self.expected_ref("IN, FROM, or WITH after FOR VALUES", self.peek_token_ref()) } } /// Parse a single partition bound value (MINVALUE, MAXVALUE, or expression). fn parse_partition_bound_value(&mut self) -> Result { if self.parse_keyword(Keyword::MINVALUE) { Ok(PartitionBoundValue::MinValue) } else if self.parse_keyword(Keyword::MAXVALUE) { Ok(PartitionBoundValue::MaxValue) } else { Ok(PartitionBoundValue::Expr(self.parse_expr()?)) } } /// Parse configuration like inheritance, partitioning, clustering information during the table creation. /// /// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language#syntax_2) /// [PostgreSQL](https://www.postgresql.org/docs/current/ddl-partitioning.html) /// [MySql](https://dev.mysql.com/doc/refman/8.4/en/create-table.html) fn parse_optional_create_table_config( &mut self, ) -> Result { let mut table_options = CreateTableOptions::None; let inherits = if self.parse_keyword(Keyword::INHERITS) { Some(self.parse_parenthesized_qualified_column_list(IsOptional::Mandatory, false)?) } else { None }; // PostgreSQL supports `WITH ( options )`, before `AS` let with_options = self.parse_options(Keyword::WITH)?; if !with_options.is_empty() { table_options = CreateTableOptions::With(with_options) } let table_properties = self.parse_options(Keyword::TBLPROPERTIES)?; if !table_properties.is_empty() { table_options = CreateTableOptions::TableProperties(table_properties); } let partition_by = if dialect_of!(self is BigQueryDialect | PostgreSqlDialect | GenericDialect) && self.parse_keywords(&[Keyword::PARTITION, Keyword::BY]) { Some(Box::new(self.parse_expr()?)) } else { None }; let mut cluster_by = None; if dialect_of!(self is BigQueryDialect | GenericDialect) { if self.parse_keywords(&[Keyword::CLUSTER, Keyword::BY]) { cluster_by = Some(WrappedCollection::NoWrapping( self.parse_comma_separated(|p| p.parse_expr())?, )); }; if let Token::Word(word) = &self.peek_token_ref().token { if word.keyword == Keyword::OPTIONS { table_options = CreateTableOptions::Options(self.parse_options(Keyword::OPTIONS)?) } }; } if !dialect_of!(self is HiveDialect) && table_options == CreateTableOptions::None { let plain_options = self.parse_plain_options()?; if !plain_options.is_empty() { table_options = CreateTableOptions::Plain(plain_options) } }; Ok(CreateTableConfiguration { partition_by, cluster_by, inherits, table_options, }) } fn parse_plain_option(&mut self) -> Result, ParserError> { // Single parameter option // if self.parse_keywords(&[Keyword::START, Keyword::TRANSACTION]) { return Ok(Some(SqlOption::Ident(Ident::new("START TRANSACTION")))); } // Custom option // if self.parse_keywords(&[Keyword::COMMENT]) { let has_eq = self.consume_token(&Token::Eq); let value = self.next_token(); let comment = match (has_eq, value.token) { (true, Token::SingleQuotedString(s)) => { Ok(Some(SqlOption::Comment(CommentDef::WithEq(s)))) } (false, Token::SingleQuotedString(s)) => { Ok(Some(SqlOption::Comment(CommentDef::WithoutEq(s)))) } (_, token) => { self.expected("Token::SingleQuotedString", TokenWithSpan::wrap(token)) } }; return comment; } // // if self.parse_keywords(&[Keyword::ENGINE]) { let _ = self.consume_token(&Token::Eq); let value = self.next_token(); let engine = match value.token { Token::Word(w) => { let parameters = if self.peek_token_ref().token == Token::LParen { self.parse_parenthesized_identifiers()? } else { vec![] }; Ok(Some(SqlOption::NamedParenthesizedList( NamedParenthesizedList { key: Ident::new("ENGINE"), name: Some(Ident::new(w.value)), values: parameters, }, ))) } _ => { return self.expected("Token::Word", value)?; } }; return engine; } // if self.parse_keywords(&[Keyword::TABLESPACE]) { let _ = self.consume_token(&Token::Eq); let value = self.next_token(); let tablespace = match value.token { Token::Word(Word { value: name, .. }) | Token::SingleQuotedString(name) => { let storage = match self.parse_keyword(Keyword::STORAGE) { true => { let _ = self.consume_token(&Token::Eq); let storage_token = self.next_token(); match &storage_token.token { Token::Word(w) => match w.value.to_uppercase().as_str() { "DISK" => Some(StorageType::Disk), "MEMORY" => Some(StorageType::Memory), _ => self .expected("Storage type (DISK or MEMORY)", storage_token)?, }, _ => self.expected("Token::Word", storage_token)?, } } false => None, }; Ok(Some(SqlOption::TableSpace(TablespaceOption { name, storage, }))) } _ => { return self.expected("Token::Word", value)?; } }; return tablespace; } // if self.parse_keyword(Keyword::UNION) { let _ = self.consume_token(&Token::Eq); let value = self.next_token(); match value.token { Token::LParen => { let tables: Vec = self.parse_comma_separated0(Parser::parse_identifier, Token::RParen)?; self.expect_token(&Token::RParen)?; return Ok(Some(SqlOption::NamedParenthesizedList( NamedParenthesizedList { key: Ident::new("UNION"), name: None, values: tables, }, ))); } _ => { return self.expected("Token::LParen", value)?; } } } // Key/Value parameter option let key = if self.parse_keywords(&[Keyword::DEFAULT, Keyword::CHARSET]) { Ident::new("DEFAULT CHARSET") } else if self.parse_keyword(Keyword::CHARSET) { Ident::new("CHARSET") } else if self.parse_keywords(&[Keyword::DEFAULT, Keyword::CHARACTER, Keyword::SET]) { Ident::new("DEFAULT CHARACTER SET") } else if self.parse_keywords(&[Keyword::CHARACTER, Keyword::SET]) { Ident::new("CHARACTER SET") } else if self.parse_keywords(&[Keyword::DEFAULT, Keyword::COLLATE]) { Ident::new("DEFAULT COLLATE") } else if self.parse_keyword(Keyword::COLLATE) { Ident::new("COLLATE") } else if self.parse_keywords(&[Keyword::DATA, Keyword::DIRECTORY]) { Ident::new("DATA DIRECTORY") } else if self.parse_keywords(&[Keyword::INDEX, Keyword::DIRECTORY]) { Ident::new("INDEX DIRECTORY") } else if self.parse_keyword(Keyword::KEY_BLOCK_SIZE) { Ident::new("KEY_BLOCK_SIZE") } else if self.parse_keyword(Keyword::ROW_FORMAT) { Ident::new("ROW_FORMAT") } else if self.parse_keyword(Keyword::PACK_KEYS) { Ident::new("PACK_KEYS") } else if self.parse_keyword(Keyword::STATS_AUTO_RECALC) { Ident::new("STATS_AUTO_RECALC") } else if self.parse_keyword(Keyword::STATS_PERSISTENT) { Ident::new("STATS_PERSISTENT") } else if self.parse_keyword(Keyword::STATS_SAMPLE_PAGES) { Ident::new("STATS_SAMPLE_PAGES") } else if self.parse_keyword(Keyword::DELAY_KEY_WRITE) { Ident::new("DELAY_KEY_WRITE") } else if self.parse_keyword(Keyword::COMPRESSION) { Ident::new("COMPRESSION") } else if self.parse_keyword(Keyword::ENCRYPTION) { Ident::new("ENCRYPTION") } else if self.parse_keyword(Keyword::MAX_ROWS) { Ident::new("MAX_ROWS") } else if self.parse_keyword(Keyword::MIN_ROWS) { Ident::new("MIN_ROWS") } else if self.parse_keyword(Keyword::AUTOEXTEND_SIZE) { Ident::new("AUTOEXTEND_SIZE") } else if self.parse_keyword(Keyword::AVG_ROW_LENGTH) { Ident::new("AVG_ROW_LENGTH") } else if self.parse_keyword(Keyword::CHECKSUM) { Ident::new("CHECKSUM") } else if self.parse_keyword(Keyword::CONNECTION) { Ident::new("CONNECTION") } else if self.parse_keyword(Keyword::ENGINE_ATTRIBUTE) { Ident::new("ENGINE_ATTRIBUTE") } else if self.parse_keyword(Keyword::PASSWORD) { Ident::new("PASSWORD") } else if self.parse_keyword(Keyword::SECONDARY_ENGINE_ATTRIBUTE) { Ident::new("SECONDARY_ENGINE_ATTRIBUTE") } else if self.parse_keyword(Keyword::INSERT_METHOD) { Ident::new("INSERT_METHOD") } else if self.parse_keyword(Keyword::AUTO_INCREMENT) { Ident::new("AUTO_INCREMENT") } else { return Ok(None); }; let _ = self.consume_token(&Token::Eq); let value = match self .maybe_parse(|parser| parser.parse_value())? .map(Expr::Value) { Some(expr) => expr, None => Expr::Identifier(self.parse_identifier()?), }; Ok(Some(SqlOption::KeyValue { key, value })) } /// Parse plain options. pub fn parse_plain_options(&mut self) -> Result, ParserError> { let mut options = Vec::new(); while let Some(option) = self.parse_plain_option()? { options.push(option); // Some dialects support comma-separated options; it shouldn't introduce ambiguity to // consume it for all dialects. let _ = self.consume_token(&Token::Comma); } Ok(options) } /// Parse optional inline comment. pub fn parse_optional_inline_comment(&mut self) -> Result, ParserError> { let comment = if self.parse_keyword(Keyword::COMMENT) { let has_eq = self.consume_token(&Token::Eq); let comment = self.parse_comment_value()?; Some(if has_eq { CommentDef::WithEq(comment) } else { CommentDef::WithoutEq(comment) }) } else { None }; Ok(comment) } /// Parse comment value. pub fn parse_comment_value(&mut self) -> Result { let next_token = self.next_token(); let value = match next_token.token { Token::SingleQuotedString(str) => str, Token::DollarQuotedString(str) => str.value, _ => self.expected("string literal", next_token)?, }; Ok(value) } /// Parse optional procedure parameters. pub fn parse_optional_procedure_parameters( &mut self, ) -> Result>, ParserError> { let mut params = vec![]; if !self.consume_token(&Token::LParen) || self.consume_token(&Token::RParen) { return Ok(Some(params)); } loop { if let Token::Word(_) = &self.peek_token_ref().token { params.push(self.parse_procedure_param()?) } let comma = self.consume_token(&Token::Comma); if self.consume_token(&Token::RParen) { // allow a trailing comma, even though it's not in standard break; } else if !comma { return self.expected_ref( "',' or ')' after parameter definition", self.peek_token_ref(), ); } } Ok(Some(params)) } /// Parse columns and constraints. pub fn parse_columns(&mut self) -> Result<(Vec, Vec), ParserError> { let mut columns = vec![]; let mut constraints = vec![]; if !self.consume_token(&Token::LParen) || self.consume_token(&Token::RParen) { return Ok((columns, constraints)); } loop { if let Some(constraint) = self.parse_optional_table_constraint()? { constraints.push(constraint); } else if let Token::Word(_) = &self.peek_token_ref().token { columns.push(self.parse_column_def()?); } else { return self.expected_ref( "column name or constraint definition", self.peek_token_ref(), ); } let comma = self.consume_token(&Token::Comma); let rparen = self.peek_token_ref().token == Token::RParen; if !comma && !rparen { return self .expected_ref("',' or ')' after column definition", self.peek_token_ref()); }; if rparen && (!comma || self.dialect.supports_column_definition_trailing_commas() || self.options.trailing_commas) { let _ = self.consume_token(&Token::RParen); break; } } Ok((columns, constraints)) } /// Parse procedure parameter. pub fn parse_procedure_param(&mut self) -> Result { let mode = if self.parse_keyword(Keyword::IN) { Some(ArgMode::In) } else if self.parse_keyword(Keyword::OUT) { Some(ArgMode::Out) } else if self.parse_keyword(Keyword::INOUT) { Some(ArgMode::InOut) } else { None }; let name = self.parse_identifier()?; let data_type = self.parse_data_type()?; let default = if self.consume_token(&Token::Eq) { Some(self.parse_expr()?) } else { None }; Ok(ProcedureParam { name, data_type, mode, default, }) } /// Parse column definition. pub fn parse_column_def(&mut self) -> Result { self.parse_column_def_inner(false) } fn parse_column_def_inner( &mut self, optional_data_type: bool, ) -> Result { let col_name = self.parse_identifier()?; let data_type = if self.is_column_type_sqlite_unspecified() { DataType::Unspecified } else if optional_data_type { self.maybe_parse(|parser| parser.parse_data_type())? .unwrap_or(DataType::Unspecified) } else { self.parse_data_type()? }; let mut options = vec![]; loop { if self.parse_keyword(Keyword::CONSTRAINT) { let name = Some(self.parse_identifier()?); if let Some(option) = self.parse_optional_column_option()? { options.push(ColumnOptionDef { name, option }); } else { return self.expected_ref( "constraint details after CONSTRAINT ", self.peek_token_ref(), ); } } else if let Some(option) = self.parse_optional_column_option()? { options.push(ColumnOptionDef { name: None, option }); } else { break; }; } Ok(ColumnDef { name: col_name, data_type, options, }) } fn is_column_type_sqlite_unspecified(&mut self) -> bool { if dialect_of!(self is SQLiteDialect) { match &self.peek_token_ref().token { Token::Word(word) => matches!( word.keyword, Keyword::CONSTRAINT | Keyword::PRIMARY | Keyword::NOT | Keyword::UNIQUE | Keyword::CHECK | Keyword::DEFAULT | Keyword::COLLATE | Keyword::REFERENCES | Keyword::GENERATED | Keyword::AS ), _ => true, // e.g. comma immediately after column name } } else { false } } /// Parse optional column option. pub fn parse_optional_column_option(&mut self) -> Result, ParserError> { if let Some(option) = self.dialect.parse_column_option(self)? { return option; } self.with_state( ColumnDefinition, |parser| -> Result, ParserError> { parser.parse_optional_column_option_inner() }, ) } fn parse_optional_column_option_inner(&mut self) -> Result, ParserError> { if self.parse_keywords(&[Keyword::CHARACTER, Keyword::SET]) { Ok(Some(ColumnOption::CharacterSet( self.parse_object_name(false)?, ))) } else if self.parse_keywords(&[Keyword::COLLATE]) { Ok(Some(ColumnOption::Collation( self.parse_object_name(false)?, ))) } else if self.parse_keywords(&[Keyword::NOT, Keyword::NULL]) { Ok(Some(ColumnOption::NotNull)) } else if self.parse_keywords(&[Keyword::COMMENT]) { Ok(Some(ColumnOption::Comment(self.parse_comment_value()?))) } else if self.parse_keyword(Keyword::NULL) { Ok(Some(ColumnOption::Null)) } else if self.parse_keyword(Keyword::DEFAULT) { Ok(Some(ColumnOption::Default(self.parse_expr()?))) } else if dialect_of!(self is ClickHouseDialect| GenericDialect) && self.parse_keyword(Keyword::MATERIALIZED) { Ok(Some(ColumnOption::Materialized(self.parse_expr()?))) } else if dialect_of!(self is ClickHouseDialect| GenericDialect) && self.parse_keyword(Keyword::ALIAS) { Ok(Some(ColumnOption::Alias(self.parse_expr()?))) } else if dialect_of!(self is ClickHouseDialect| GenericDialect) && self.parse_keyword(Keyword::EPHEMERAL) { // The expression is optional for the EPHEMERAL syntax, so we need to check // if the column definition has remaining tokens before parsing the expression. if matches!(self.peek_token_ref().token, Token::Comma | Token::RParen) { Ok(Some(ColumnOption::Ephemeral(None))) } else { Ok(Some(ColumnOption::Ephemeral(Some(self.parse_expr()?)))) } } else if self.parse_keywords(&[Keyword::PRIMARY, Keyword::KEY]) { let characteristics = self.parse_constraint_characteristics()?; Ok(Some( PrimaryKeyConstraint { name: None, index_name: None, index_type: None, columns: vec![], index_options: vec![], characteristics, } .into(), )) } else if self.parse_keyword(Keyword::UNIQUE) { let index_type_display = if self.dialect.supports_key_column_option() && self.parse_keyword(Keyword::KEY) { KeyOrIndexDisplay::Key } else { KeyOrIndexDisplay::None }; let characteristics = self.parse_constraint_characteristics()?; Ok(Some( UniqueConstraint { name: None, index_name: None, index_type_display, index_type: None, columns: vec![], index_options: vec![], characteristics, nulls_distinct: NullsDistinctOption::None, } .into(), )) } else if self.dialect.supports_key_column_option() && self.parse_keyword(Keyword::KEY) { // In MySQL, `KEY` in a column definition is shorthand for `PRIMARY KEY`. // See: https://dev.mysql.com/doc/refman/8.4/en/create-table.html let characteristics = self.parse_constraint_characteristics()?; Ok(Some( PrimaryKeyConstraint { name: None, index_name: None, index_type: None, columns: vec![], index_options: vec![], characteristics, } .into(), )) } else if self.parse_keyword(Keyword::REFERENCES) { let foreign_table = self.parse_object_name(false)?; // PostgreSQL allows omitting the column list and // uses the primary key column of the foreign table by default let referred_columns = self.parse_parenthesized_column_list(Optional, false)?; let mut match_kind = None; let mut on_delete = None; let mut on_update = None; loop { if match_kind.is_none() && self.parse_keyword(Keyword::MATCH) { match_kind = Some(self.parse_match_kind()?); } else if on_delete.is_none() && self.parse_keywords(&[Keyword::ON, Keyword::DELETE]) { on_delete = Some(self.parse_referential_action()?); } else if on_update.is_none() && self.parse_keywords(&[Keyword::ON, Keyword::UPDATE]) { on_update = Some(self.parse_referential_action()?); } else { break; } } let characteristics = self.parse_constraint_characteristics()?; Ok(Some( ForeignKeyConstraint { name: None, // Column-level constraints don't have names index_name: None, // Not applicable for column-level constraints columns: vec![], // Not applicable for column-level constraints foreign_table, referred_columns, on_delete, on_update, match_kind, characteristics, } .into(), )) } else if self.parse_keyword(Keyword::CHECK) { self.expect_token(&Token::LParen)?; // since `CHECK` requires parentheses, we can parse the inner expression in ParserState::Normal let expr: Expr = self.with_state(ParserState::Normal, |p| p.parse_expr())?; self.expect_token(&Token::RParen)?; let enforced = if self.parse_keyword(Keyword::ENFORCED) { Some(true) } else if self.parse_keywords(&[Keyword::NOT, Keyword::ENFORCED]) { Some(false) } else { None }; Ok(Some( CheckConstraint { name: None, // Column-level check constraints don't have names expr: Box::new(expr), enforced, } .into(), )) } else if self.parse_keyword(Keyword::AUTO_INCREMENT) && dialect_of!(self is MySqlDialect | GenericDialect) { // Support AUTO_INCREMENT for MySQL Ok(Some(ColumnOption::DialectSpecific(vec![ Token::make_keyword("AUTO_INCREMENT"), ]))) } else if self.parse_keyword(Keyword::AUTOINCREMENT) && dialect_of!(self is SQLiteDialect | GenericDialect) { // Support AUTOINCREMENT for SQLite Ok(Some(ColumnOption::DialectSpecific(vec![ Token::make_keyword("AUTOINCREMENT"), ]))) } else if self.parse_keyword(Keyword::ASC) && self.dialect.supports_asc_desc_in_column_definition() { // Support ASC for SQLite Ok(Some(ColumnOption::DialectSpecific(vec![ Token::make_keyword("ASC"), ]))) } else if self.parse_keyword(Keyword::DESC) && self.dialect.supports_asc_desc_in_column_definition() { // Support DESC for SQLite Ok(Some(ColumnOption::DialectSpecific(vec![ Token::make_keyword("DESC"), ]))) } else if self.parse_keywords(&[Keyword::ON, Keyword::UPDATE]) && dialect_of!(self is MySqlDialect | GenericDialect) { let expr = self.parse_expr()?; Ok(Some(ColumnOption::OnUpdate(expr))) } else if self.parse_keyword(Keyword::GENERATED) { self.parse_optional_column_option_generated() } else if dialect_of!(self is BigQueryDialect | GenericDialect) && self.parse_keyword(Keyword::OPTIONS) { self.prev_token(); Ok(Some(ColumnOption::Options( self.parse_options(Keyword::OPTIONS)?, ))) } else if self.parse_keyword(Keyword::AS) && dialect_of!(self is MySqlDialect | SQLiteDialect | DuckDbDialect | GenericDialect) { self.parse_optional_column_option_as() } else if self.parse_keyword(Keyword::SRID) && dialect_of!(self is MySqlDialect | GenericDialect) { Ok(Some(ColumnOption::Srid(Box::new(self.parse_expr()?)))) } else if self.parse_keyword(Keyword::IDENTITY) && dialect_of!(self is MsSqlDialect | GenericDialect) { let parameters = if self.consume_token(&Token::LParen) { let seed = self.parse_number()?; self.expect_token(&Token::Comma)?; let increment = self.parse_number()?; self.expect_token(&Token::RParen)?; Some(IdentityPropertyFormatKind::FunctionCall( IdentityParameters { seed, increment }, )) } else { None }; Ok(Some(ColumnOption::Identity( IdentityPropertyKind::Identity(IdentityProperty { parameters, order: None, }), ))) } else if dialect_of!(self is SQLiteDialect | GenericDialect) && self.parse_keywords(&[Keyword::ON, Keyword::CONFLICT]) { // Support ON CONFLICT for SQLite Ok(Some(ColumnOption::OnConflict( self.expect_one_of_keywords(&[ Keyword::ROLLBACK, Keyword::ABORT, Keyword::FAIL, Keyword::IGNORE, Keyword::REPLACE, ])?, ))) } else if self.parse_keyword(Keyword::INVISIBLE) { Ok(Some(ColumnOption::Invisible)) } else { Ok(None) } } pub(crate) fn parse_tag(&mut self) -> Result { let name = self.parse_object_name(false)?; self.expect_token(&Token::Eq)?; let value = self.parse_literal_string()?; Ok(Tag::new(name, value)) } fn parse_optional_column_option_generated( &mut self, ) -> Result, ParserError> { if self.parse_keywords(&[Keyword::ALWAYS, Keyword::AS, Keyword::IDENTITY]) { let mut sequence_options = vec![]; if self.expect_token(&Token::LParen).is_ok() { sequence_options = self.parse_create_sequence_options()?; self.expect_token(&Token::RParen)?; } Ok(Some(ColumnOption::Generated { generated_as: GeneratedAs::Always, sequence_options: Some(sequence_options), generation_expr: None, generation_expr_mode: None, generated_keyword: true, })) } else if self.parse_keywords(&[ Keyword::BY, Keyword::DEFAULT, Keyword::AS, Keyword::IDENTITY, ]) { let mut sequence_options = vec![]; if self.expect_token(&Token::LParen).is_ok() { sequence_options = self.parse_create_sequence_options()?; self.expect_token(&Token::RParen)?; } Ok(Some(ColumnOption::Generated { generated_as: GeneratedAs::ByDefault, sequence_options: Some(sequence_options), generation_expr: None, generation_expr_mode: None, generated_keyword: true, })) } else if self.parse_keywords(&[Keyword::ALWAYS, Keyword::AS]) { if self.expect_token(&Token::LParen).is_ok() { let expr: Expr = self.with_state(ParserState::Normal, |p| p.parse_expr())?; self.expect_token(&Token::RParen)?; let (gen_as, expr_mode) = if self.parse_keywords(&[Keyword::STORED]) { Ok(( GeneratedAs::ExpStored, Some(GeneratedExpressionMode::Stored), )) } else if dialect_of!(self is PostgreSqlDialect) { // Postgres' AS IDENTITY branches are above, this one needs STORED self.expected_ref("STORED", self.peek_token_ref()) } else if self.parse_keywords(&[Keyword::VIRTUAL]) { Ok((GeneratedAs::Always, Some(GeneratedExpressionMode::Virtual))) } else { Ok((GeneratedAs::Always, None)) }?; Ok(Some(ColumnOption::Generated { generated_as: gen_as, sequence_options: None, generation_expr: Some(expr), generation_expr_mode: expr_mode, generated_keyword: true, })) } else { Ok(None) } } else { Ok(None) } } fn parse_optional_column_option_as(&mut self) -> Result, ParserError> { // Some DBs allow 'AS (expr)', shorthand for GENERATED ALWAYS AS self.expect_token(&Token::LParen)?; let expr = self.parse_expr()?; self.expect_token(&Token::RParen)?; let (gen_as, expr_mode) = if self.parse_keywords(&[Keyword::STORED]) { ( GeneratedAs::ExpStored, Some(GeneratedExpressionMode::Stored), ) } else if self.parse_keywords(&[Keyword::VIRTUAL]) { (GeneratedAs::Always, Some(GeneratedExpressionMode::Virtual)) } else { (GeneratedAs::Always, None) }; Ok(Some(ColumnOption::Generated { generated_as: gen_as, sequence_options: None, generation_expr: Some(expr), generation_expr_mode: expr_mode, generated_keyword: false, })) } /// Parse optional `CLUSTERED BY` clause for Hive/Generic dialects. pub fn parse_optional_clustered_by(&mut self) -> Result, ParserError> { let clustered_by = if dialect_of!(self is HiveDialect|GenericDialect) && self.parse_keywords(&[Keyword::CLUSTERED, Keyword::BY]) { let columns = self.parse_parenthesized_column_list(Mandatory, false)?; let sorted_by = if self.parse_keywords(&[Keyword::SORTED, Keyword::BY]) { self.expect_token(&Token::LParen)?; let sorted_by_columns = self.parse_comma_separated(|p| p.parse_order_by_expr())?; self.expect_token(&Token::RParen)?; Some(sorted_by_columns) } else { None }; self.expect_keyword_is(Keyword::INTO)?; let num_buckets = self.parse_number_value()?.value; self.expect_keyword_is(Keyword::BUCKETS)?; Some(ClusteredBy { columns, sorted_by, num_buckets, }) } else { None }; Ok(clustered_by) } /// Parse a referential action used in foreign key clauses. /// /// Recognized forms: `RESTRICT`, `CASCADE`, `SET NULL`, `NO ACTION`, `SET DEFAULT`. pub fn parse_referential_action(&mut self) -> Result { if self.parse_keyword(Keyword::RESTRICT) { Ok(ReferentialAction::Restrict) } else if self.parse_keyword(Keyword::CASCADE) { Ok(ReferentialAction::Cascade) } else if self.parse_keywords(&[Keyword::SET, Keyword::NULL]) { Ok(ReferentialAction::SetNull) } else if self.parse_keywords(&[Keyword::NO, Keyword::ACTION]) { Ok(ReferentialAction::NoAction) } else if self.parse_keywords(&[Keyword::SET, Keyword::DEFAULT]) { Ok(ReferentialAction::SetDefault) } else { self.expected_ref( "one of RESTRICT, CASCADE, SET NULL, NO ACTION or SET DEFAULT", self.peek_token_ref(), ) } } /// Parse a `MATCH` kind for constraint references: `FULL`, `PARTIAL`, or `SIMPLE`. pub fn parse_match_kind(&mut self) -> Result { if self.parse_keyword(Keyword::FULL) { Ok(ConstraintReferenceMatchKind::Full) } else if self.parse_keyword(Keyword::PARTIAL) { Ok(ConstraintReferenceMatchKind::Partial) } else if self.parse_keyword(Keyword::SIMPLE) { Ok(ConstraintReferenceMatchKind::Simple) } else { self.expected_ref("one of FULL, PARTIAL or SIMPLE", self.peek_token_ref()) } } /// Parse `index_name [ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]` /// after `{ PRIMARY KEY | UNIQUE } USING INDEX`. fn parse_constraint_using_index( &mut self, name: Option, ) -> Result { let index_name = self.parse_identifier()?; let characteristics = self.parse_constraint_characteristics()?; Ok(ConstraintUsingIndex { name, index_name, characteristics, }) } /// Parse optional constraint characteristics such as `DEFERRABLE`, `INITIALLY` and `ENFORCED`. pub fn parse_constraint_characteristics( &mut self, ) -> Result, ParserError> { let mut cc = ConstraintCharacteristics::default(); loop { if cc.deferrable.is_none() && self.parse_keywords(&[Keyword::NOT, Keyword::DEFERRABLE]) { cc.deferrable = Some(false); } else if cc.deferrable.is_none() && self.parse_keyword(Keyword::DEFERRABLE) { cc.deferrable = Some(true); } else if cc.initially.is_none() && self.parse_keyword(Keyword::INITIALLY) { if self.parse_keyword(Keyword::DEFERRED) { cc.initially = Some(DeferrableInitial::Deferred); } else if self.parse_keyword(Keyword::IMMEDIATE) { cc.initially = Some(DeferrableInitial::Immediate); } else { self.expected_ref("one of DEFERRED or IMMEDIATE", self.peek_token_ref())?; } } else if cc.enforced.is_none() && self.parse_keyword(Keyword::ENFORCED) { cc.enforced = Some(true); } else if cc.enforced.is_none() && self.parse_keywords(&[Keyword::NOT, Keyword::ENFORCED]) { cc.enforced = Some(false); } else { break; } } if cc.deferrable.is_some() || cc.initially.is_some() || cc.enforced.is_some() { Ok(Some(cc)) } else { Ok(None) } } /// Parse an optional table constraint (e.g. `PRIMARY KEY`, `UNIQUE`, `FOREIGN KEY`, `CHECK`). pub fn parse_optional_table_constraint( &mut self, ) -> Result, ParserError> { let name = if self.parse_keyword(Keyword::CONSTRAINT) { if self.dialect.supports_constraint_keyword_without_name() && self .peek_one_of_keywords(&[ Keyword::CHECK, Keyword::PRIMARY, Keyword::UNIQUE, Keyword::FOREIGN, ]) .is_some() { None } else { Some(self.parse_identifier()?) } } else { None }; let next_token = self.next_token(); match next_token.token { Token::Word(w) if w.keyword == Keyword::UNIQUE => { // PostgreSQL: UNIQUE USING INDEX index_name // https://www.postgresql.org/docs/current/sql-altertable.html if self.parse_keywords(&[Keyword::USING, Keyword::INDEX]) { return Ok(Some(TableConstraint::UniqueUsingIndex( self.parse_constraint_using_index(name)?, ))); } let index_type_display = self.parse_index_type_display(); if !dialect_of!(self is GenericDialect | MySqlDialect) && !index_type_display.is_none() { return self.expected_ref( "`index_name` or `(column_name [, ...])`", self.peek_token_ref(), ); } let nulls_distinct = self.parse_optional_nulls_distinct()?; // optional index name let index_name = self.parse_optional_ident()?; let index_type = self.parse_optional_using_then_index_type()?; let columns = self.parse_parenthesized_index_column_list()?; let index_options = self.parse_index_options()?; let characteristics = self.parse_constraint_characteristics()?; Ok(Some( UniqueConstraint { name, index_name, index_type_display, index_type, columns, index_options, characteristics, nulls_distinct, } .into(), )) } Token::Word(w) if w.keyword == Keyword::PRIMARY => { // after `PRIMARY` always stay `KEY` self.expect_keyword_is(Keyword::KEY)?; // PostgreSQL: PRIMARY KEY USING INDEX index_name // https://www.postgresql.org/docs/current/sql-altertable.html if self.parse_keywords(&[Keyword::USING, Keyword::INDEX]) { return Ok(Some(TableConstraint::PrimaryKeyUsingIndex( self.parse_constraint_using_index(name)?, ))); } // optional index name let index_name = self.parse_optional_ident()?; let index_type = self.parse_optional_using_then_index_type()?; let columns = self.parse_parenthesized_index_column_list()?; let index_options = self.parse_index_options()?; let characteristics = self.parse_constraint_characteristics()?; Ok(Some( PrimaryKeyConstraint { name, index_name, index_type, columns, index_options, characteristics, } .into(), )) } Token::Word(w) if w.keyword == Keyword::FOREIGN => { self.expect_keyword_is(Keyword::KEY)?; let index_name = self.parse_optional_ident()?; let columns = self.parse_parenthesized_column_list(Mandatory, false)?; self.expect_keyword_is(Keyword::REFERENCES)?; let foreign_table = self.parse_object_name(false)?; let referred_columns = self.parse_parenthesized_column_list(Optional, false)?; let mut match_kind = None; let mut on_delete = None; let mut on_update = None; loop { if match_kind.is_none() && self.parse_keyword(Keyword::MATCH) { match_kind = Some(self.parse_match_kind()?); } else if on_delete.is_none() && self.parse_keywords(&[Keyword::ON, Keyword::DELETE]) { on_delete = Some(self.parse_referential_action()?); } else if on_update.is_none() && self.parse_keywords(&[Keyword::ON, Keyword::UPDATE]) { on_update = Some(self.parse_referential_action()?); } else { break; } } let characteristics = self.parse_constraint_characteristics()?; Ok(Some( ForeignKeyConstraint { name, index_name, columns, foreign_table, referred_columns, on_delete, on_update, match_kind, characteristics, } .into(), )) } Token::Word(w) if w.keyword == Keyword::CHECK => { self.expect_token(&Token::LParen)?; let expr = Box::new(self.parse_expr()?); self.expect_token(&Token::RParen)?; let enforced = if self.parse_keyword(Keyword::ENFORCED) { Some(true) } else if self.parse_keywords(&[Keyword::NOT, Keyword::ENFORCED]) { Some(false) } else { None }; Ok(Some( CheckConstraint { name, expr, enforced, } .into(), )) } Token::Word(w) if (w.keyword == Keyword::INDEX || w.keyword == Keyword::KEY) && dialect_of!(self is GenericDialect | MySqlDialect) && name.is_none() => { let display_as_key = w.keyword == Keyword::KEY; let name = match &self.peek_token_ref().token { Token::Word(word) if word.keyword == Keyword::USING => None, _ => self.parse_optional_ident()?, }; let index_type = self.parse_optional_using_then_index_type()?; let columns = self.parse_parenthesized_index_column_list()?; let index_options = self.parse_index_options()?; Ok(Some( IndexConstraint { display_as_key, name, index_type, columns, index_options, } .into(), )) } Token::Word(w) if (w.keyword == Keyword::FULLTEXT || w.keyword == Keyword::SPATIAL) && dialect_of!(self is GenericDialect | MySqlDialect) => { if let Some(name) = name { return self.expected( "FULLTEXT or SPATIAL option without constraint name", TokenWithSpan { token: Token::make_keyword(&name.to_string()), span: next_token.span, }, ); } let fulltext = w.keyword == Keyword::FULLTEXT; let index_type_display = self.parse_index_type_display(); let opt_index_name = self.parse_optional_ident()?; let columns = self.parse_parenthesized_index_column_list()?; Ok(Some( FullTextOrSpatialConstraint { fulltext, index_type_display, opt_index_name, columns, } .into(), )) } _ => { if name.is_some() { self.expected("PRIMARY, UNIQUE, FOREIGN, or CHECK", next_token) } else { self.prev_token(); Ok(None) } } } } fn parse_optional_nulls_distinct(&mut self) -> Result { Ok(if self.parse_keyword(Keyword::NULLS) { let not = self.parse_keyword(Keyword::NOT); self.expect_keyword_is(Keyword::DISTINCT)?; if not { NullsDistinctOption::NotDistinct } else { NullsDistinctOption::Distinct } } else { NullsDistinctOption::None }) } /// Optionally parse a parenthesized list of `SqlOption`s introduced by `keyword`. pub fn maybe_parse_options( &mut self, keyword: Keyword, ) -> Result>, ParserError> { if let Token::Word(word) = &self.peek_token_ref().token { if word.keyword == keyword { return Ok(Some(self.parse_options(keyword)?)); } }; Ok(None) } /// Parse a parenthesized list of `SqlOption`s following `keyword`, or return an empty vec. pub fn parse_options(&mut self, keyword: Keyword) -> Result, ParserError> { if self.parse_keyword(keyword) { self.expect_token(&Token::LParen)?; let options = self.parse_comma_separated0(Parser::parse_sql_option, Token::RParen)?; self.expect_token(&Token::RParen)?; Ok(options) } else { Ok(vec![]) } } /// Parse options introduced by one of `keywords` followed by a parenthesized list. pub fn parse_options_with_keywords( &mut self, keywords: &[Keyword], ) -> Result, ParserError> { if self.parse_keywords(keywords) { self.expect_token(&Token::LParen)?; let options = self.parse_comma_separated(Parser::parse_sql_option)?; self.expect_token(&Token::RParen)?; Ok(options) } else { Ok(vec![]) } } /// Parse an index type token (e.g. `BTREE`, `HASH`, or a custom identifier). pub fn parse_index_type(&mut self) -> Result { Ok(if self.parse_keyword(Keyword::BTREE) { IndexType::BTree } else if self.parse_keyword(Keyword::HASH) { IndexType::Hash } else if self.parse_keyword(Keyword::GIN) { IndexType::GIN } else if self.parse_keyword(Keyword::GIST) { IndexType::GiST } else if self.parse_keyword(Keyword::SPGIST) { IndexType::SPGiST } else if self.parse_keyword(Keyword::BRIN) { IndexType::BRIN } else if self.parse_keyword(Keyword::BLOOM) { IndexType::Bloom } else { IndexType::Custom(self.parse_identifier()?) }) } /// Optionally parse the `USING` keyword, followed by an [IndexType] /// Example: /// ```sql //// USING BTREE (name, age DESC) /// ``` /// Optionally parse `USING ` and return the parsed `IndexType` if present. pub fn parse_optional_using_then_index_type( &mut self, ) -> Result, ParserError> { if self.parse_keyword(Keyword::USING) { Ok(Some(self.parse_index_type()?)) } else { Ok(None) } } /// Parse `[ident]`, mostly `ident` is name, like: /// `window_name`, `index_name`, ... /// Parse an optional identifier, returning `Some(Ident)` if present. pub fn parse_optional_ident(&mut self) -> Result, ParserError> { self.maybe_parse(|parser| parser.parse_identifier()) } #[must_use] /// Parse optional `KEY` or `INDEX` display tokens used in index/constraint declarations. pub fn parse_index_type_display(&mut self) -> KeyOrIndexDisplay { if self.parse_keyword(Keyword::KEY) { KeyOrIndexDisplay::Key } else if self.parse_keyword(Keyword::INDEX) { KeyOrIndexDisplay::Index } else { KeyOrIndexDisplay::None } } /// Parse an optional index option such as `USING ` or `COMMENT `. pub fn parse_optional_index_option(&mut self) -> Result, ParserError> { if let Some(index_type) = self.parse_optional_using_then_index_type()? { Ok(Some(IndexOption::Using(index_type))) } else if self.parse_keyword(Keyword::COMMENT) { let s = self.parse_literal_string()?; Ok(Some(IndexOption::Comment(s))) } else { Ok(None) } } /// Parse zero or more index options and return them as a vector. pub fn parse_index_options(&mut self) -> Result, ParserError> { let mut options = Vec::new(); loop { match self.parse_optional_index_option()? { Some(index_option) => options.push(index_option), None => return Ok(options), } } } /// Parse a single `SqlOption` used by various dialect-specific DDL statements. pub fn parse_sql_option(&mut self) -> Result { let is_mssql = dialect_of!(self is MsSqlDialect|GenericDialect); match &self.peek_token_ref().token { Token::Word(w) if w.keyword == Keyword::HEAP && is_mssql => { Ok(SqlOption::Ident(self.parse_identifier()?)) } Token::Word(w) if w.keyword == Keyword::PARTITION && is_mssql => { self.parse_option_partition() } Token::Word(w) if w.keyword == Keyword::CLUSTERED && is_mssql => { self.parse_option_clustered() } _ => { let name = self.parse_identifier()?; self.expect_token(&Token::Eq)?; let value = self.parse_expr()?; Ok(SqlOption::KeyValue { key: name, value }) } } } /// Parse a `CLUSTERED` table option (MSSQL-specific syntaxes supported). pub fn parse_option_clustered(&mut self) -> Result { if self.parse_keywords(&[ Keyword::CLUSTERED, Keyword::COLUMNSTORE, Keyword::INDEX, Keyword::ORDER, ]) { Ok(SqlOption::Clustered( TableOptionsClustered::ColumnstoreIndexOrder( self.parse_parenthesized_column_list(IsOptional::Mandatory, false)?, ), )) } else if self.parse_keywords(&[Keyword::CLUSTERED, Keyword::COLUMNSTORE, Keyword::INDEX]) { Ok(SqlOption::Clustered( TableOptionsClustered::ColumnstoreIndex, )) } else if self.parse_keywords(&[Keyword::CLUSTERED, Keyword::INDEX]) { self.expect_token(&Token::LParen)?; let columns = self.parse_comma_separated(|p| { let name = p.parse_identifier()?; let asc = p.parse_asc_desc(); Ok(ClusteredIndex { name, asc }) })?; self.expect_token(&Token::RParen)?; Ok(SqlOption::Clustered(TableOptionsClustered::Index(columns))) } else { Err(ParserError::ParserError( "invalid CLUSTERED sequence".to_string(), )) } } /// Parse a `PARTITION(...) FOR VALUES(...)` table option. pub fn parse_option_partition(&mut self) -> Result { self.expect_keyword_is(Keyword::PARTITION)?; self.expect_token(&Token::LParen)?; let column_name = self.parse_identifier()?; self.expect_keyword_is(Keyword::RANGE)?; let range_direction = if self.parse_keyword(Keyword::LEFT) { Some(PartitionRangeDirection::Left) } else if self.parse_keyword(Keyword::RIGHT) { Some(PartitionRangeDirection::Right) } else { None }; self.expect_keywords(&[Keyword::FOR, Keyword::VALUES])?; self.expect_token(&Token::LParen)?; let for_values = self.parse_comma_separated(Parser::parse_expr)?; self.expect_token(&Token::RParen)?; self.expect_token(&Token::RParen)?; Ok(SqlOption::Partition { column_name, range_direction, for_values, }) } /// Parse a parenthesized list of partition expressions and return a `Partition` value. pub fn parse_partition(&mut self) -> Result { self.expect_token(&Token::LParen)?; let partitions = self.parse_comma_separated(Parser::parse_expr)?; self.expect_token(&Token::RParen)?; Ok(Partition::Partitions(partitions)) } /// Parse a parenthesized `SELECT` projection used for projection-based operations. pub fn parse_projection_select(&mut self) -> Result { self.expect_token(&Token::LParen)?; self.expect_keyword_is(Keyword::SELECT)?; let projection = self.parse_projection()?; let group_by = self.parse_optional_group_by()?; let order_by = self.parse_optional_order_by()?; self.expect_token(&Token::RParen)?; Ok(ProjectionSelect { projection, group_by, order_by, }) } /// Parse `ALTER TABLE ... ADD PROJECTION ...` operation. pub fn parse_alter_table_add_projection(&mut self) -> Result { let if_not_exists = self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]); let name = self.parse_identifier()?; let query = self.parse_projection_select()?; Ok(AlterTableOperation::AddProjection { if_not_exists, name, select: query, }) } /// Parse Redshift `ALTER SORTKEY (column_list)`. /// /// See fn parse_alter_sort_key(&mut self) -> Result { self.expect_keyword_is(Keyword::ALTER)?; self.expect_keyword_is(Keyword::SORTKEY)?; self.expect_token(&Token::LParen)?; let columns = self.parse_comma_separated(|p| p.parse_expr())?; self.expect_token(&Token::RParen)?; Ok(AlterTableOperation::AlterSortKey { columns }) } /// Parse a single `ALTER TABLE` operation and return an `AlterTableOperation`. pub fn parse_alter_table_operation(&mut self) -> Result { let operation = if self.parse_keyword(Keyword::ADD) { if let Some(constraint) = self.parse_optional_table_constraint()? { let not_valid = self.parse_keywords(&[Keyword::NOT, Keyword::VALID]); AlterTableOperation::AddConstraint { constraint, not_valid, } } else if dialect_of!(self is ClickHouseDialect|GenericDialect) && self.parse_keyword(Keyword::PROJECTION) { return self.parse_alter_table_add_projection(); } else { let if_not_exists = self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]); let mut new_partitions = vec![]; loop { if self.parse_keyword(Keyword::PARTITION) { new_partitions.push(self.parse_partition()?); } else { break; } } if !new_partitions.is_empty() { AlterTableOperation::AddPartitions { if_not_exists, new_partitions, } } else { let column_keyword = self.parse_keyword(Keyword::COLUMN); let if_not_exists = if dialect_of!(self is PostgreSqlDialect | BigQueryDialect | DuckDbDialect | GenericDialect) { self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]) || if_not_exists } else { false }; let column_def = self.parse_column_def()?; let column_position = self.parse_column_position()?; AlterTableOperation::AddColumn { column_keyword, if_not_exists, column_def, column_position, } } } } else if self.parse_keyword(Keyword::RENAME) { if dialect_of!(self is PostgreSqlDialect) && self.parse_keyword(Keyword::CONSTRAINT) { let old_name = self.parse_identifier()?; self.expect_keyword_is(Keyword::TO)?; let new_name = self.parse_identifier()?; AlterTableOperation::RenameConstraint { old_name, new_name } } else if self.parse_keyword(Keyword::TO) { let table_name = self.parse_object_name(false)?; AlterTableOperation::RenameTable { table_name: RenameTableNameKind::To(table_name), } } else if self.parse_keyword(Keyword::AS) { let table_name = self.parse_object_name(false)?; AlterTableOperation::RenameTable { table_name: RenameTableNameKind::As(table_name), } } else { let _ = self.parse_keyword(Keyword::COLUMN); // [ COLUMN ] let old_column_name = self.parse_identifier()?; self.expect_keyword_is(Keyword::TO)?; let new_column_name = self.parse_identifier()?; AlterTableOperation::RenameColumn { old_column_name, new_column_name, } } } else if self.parse_keyword(Keyword::DISABLE) { if self.parse_keywords(&[Keyword::ROW, Keyword::LEVEL, Keyword::SECURITY]) { AlterTableOperation::DisableRowLevelSecurity {} } else if self.parse_keyword(Keyword::RULE) { let name = self.parse_identifier()?; AlterTableOperation::DisableRule { name } } else if self.parse_keyword(Keyword::TRIGGER) { let name = self.parse_identifier()?; AlterTableOperation::DisableTrigger { name } } else { return self.expected_ref( "ROW LEVEL SECURITY, RULE, or TRIGGER after DISABLE", self.peek_token_ref(), ); } } else if self.parse_keyword(Keyword::ENABLE) { if self.parse_keywords(&[Keyword::ALWAYS, Keyword::RULE]) { let name = self.parse_identifier()?; AlterTableOperation::EnableAlwaysRule { name } } else if self.parse_keywords(&[Keyword::ALWAYS, Keyword::TRIGGER]) { let name = self.parse_identifier()?; AlterTableOperation::EnableAlwaysTrigger { name } } else if self.parse_keywords(&[Keyword::ROW, Keyword::LEVEL, Keyword::SECURITY]) { AlterTableOperation::EnableRowLevelSecurity {} } else if self.parse_keywords(&[Keyword::REPLICA, Keyword::RULE]) { let name = self.parse_identifier()?; AlterTableOperation::EnableReplicaRule { name } } else if self.parse_keywords(&[Keyword::REPLICA, Keyword::TRIGGER]) { let name = self.parse_identifier()?; AlterTableOperation::EnableReplicaTrigger { name } } else if self.parse_keyword(Keyword::RULE) { let name = self.parse_identifier()?; AlterTableOperation::EnableRule { name } } else if self.parse_keyword(Keyword::TRIGGER) { let name = self.parse_identifier()?; AlterTableOperation::EnableTrigger { name } } else { return self.expected_ref( "ALWAYS, REPLICA, ROW LEVEL SECURITY, RULE, or TRIGGER after ENABLE", self.peek_token_ref(), ); } } else if self.parse_keywords(&[ Keyword::FORCE, Keyword::ROW, Keyword::LEVEL, Keyword::SECURITY, ]) { AlterTableOperation::ForceRowLevelSecurity } else if self.parse_keywords(&[ Keyword::NO, Keyword::FORCE, Keyword::ROW, Keyword::LEVEL, Keyword::SECURITY, ]) { AlterTableOperation::NoForceRowLevelSecurity } else if self.parse_keywords(&[Keyword::CLEAR, Keyword::PROJECTION]) && dialect_of!(self is ClickHouseDialect|GenericDialect) { let if_exists = self.parse_keywords(&[Keyword::IF, Keyword::EXISTS]); let name = self.parse_identifier()?; let partition = if self.parse_keywords(&[Keyword::IN, Keyword::PARTITION]) { Some(self.parse_identifier()?) } else { None }; AlterTableOperation::ClearProjection { if_exists, name, partition, } } else if self.parse_keywords(&[Keyword::MATERIALIZE, Keyword::PROJECTION]) && dialect_of!(self is ClickHouseDialect|GenericDialect) { let if_exists = self.parse_keywords(&[Keyword::IF, Keyword::EXISTS]); let name = self.parse_identifier()?; let partition = if self.parse_keywords(&[Keyword::IN, Keyword::PARTITION]) { Some(self.parse_identifier()?) } else { None }; AlterTableOperation::MaterializeProjection { if_exists, name, partition, } } else if self.parse_keyword(Keyword::DROP) { if self.parse_keywords(&[Keyword::IF, Keyword::EXISTS, Keyword::PARTITION]) { self.expect_token(&Token::LParen)?; let partitions = self.parse_comma_separated(Parser::parse_expr)?; self.expect_token(&Token::RParen)?; AlterTableOperation::DropPartitions { partitions, if_exists: true, } } else if self.parse_keyword(Keyword::PARTITION) { self.expect_token(&Token::LParen)?; let partitions = self.parse_comma_separated(Parser::parse_expr)?; self.expect_token(&Token::RParen)?; AlterTableOperation::DropPartitions { partitions, if_exists: false, } } else if self.parse_keyword(Keyword::CONSTRAINT) { let if_exists = self.parse_keywords(&[Keyword::IF, Keyword::EXISTS]); let name = self.parse_identifier()?; let drop_behavior = self.parse_optional_drop_behavior(); AlterTableOperation::DropConstraint { if_exists, name, drop_behavior, } } else if self.parse_keywords(&[Keyword::PRIMARY, Keyword::KEY]) { let drop_behavior = self.parse_optional_drop_behavior(); AlterTableOperation::DropPrimaryKey { drop_behavior } } else if self.parse_keywords(&[Keyword::FOREIGN, Keyword::KEY]) { let name = self.parse_identifier()?; let drop_behavior = self.parse_optional_drop_behavior(); AlterTableOperation::DropForeignKey { name, drop_behavior, } } else if self.parse_keyword(Keyword::INDEX) { let name = self.parse_identifier()?; AlterTableOperation::DropIndex { name } } else if self.parse_keyword(Keyword::PROJECTION) && dialect_of!(self is ClickHouseDialect|GenericDialect) { let if_exists = self.parse_keywords(&[Keyword::IF, Keyword::EXISTS]); let name = self.parse_identifier()?; AlterTableOperation::DropProjection { if_exists, name } } else if self.parse_keywords(&[Keyword::CLUSTERING, Keyword::KEY]) { AlterTableOperation::DropClusteringKey } else { let has_column_keyword = self.parse_keyword(Keyword::COLUMN); // [ COLUMN ] let if_exists = self.parse_keywords(&[Keyword::IF, Keyword::EXISTS]); let column_names = if self.dialect.supports_comma_separated_drop_column_list() { self.parse_comma_separated(Parser::parse_identifier)? } else { vec![self.parse_identifier()?] }; let drop_behavior = self.parse_optional_drop_behavior(); AlterTableOperation::DropColumn { has_column_keyword, column_names, if_exists, drop_behavior, } } } else if self.parse_keyword(Keyword::PARTITION) { self.expect_token(&Token::LParen)?; let before = self.parse_comma_separated(Parser::parse_expr)?; self.expect_token(&Token::RParen)?; self.expect_keyword_is(Keyword::RENAME)?; self.expect_keywords(&[Keyword::TO, Keyword::PARTITION])?; self.expect_token(&Token::LParen)?; let renames = self.parse_comma_separated(Parser::parse_expr)?; self.expect_token(&Token::RParen)?; AlterTableOperation::RenamePartitions { old_partitions: before, new_partitions: renames, } } else if self.parse_keyword(Keyword::CHANGE) { let _ = self.parse_keyword(Keyword::COLUMN); // [ COLUMN ] let old_name = self.parse_identifier()?; let new_name = self.parse_identifier()?; let data_type = self.parse_data_type()?; let mut options = vec![]; while let Some(option) = self.parse_optional_column_option()? { options.push(option); } let column_position = self.parse_column_position()?; AlterTableOperation::ChangeColumn { old_name, new_name, data_type, options, column_position, } } else if self.parse_keyword(Keyword::MODIFY) { let _ = self.parse_keyword(Keyword::COLUMN); // [ COLUMN ] let col_name = self.parse_identifier()?; let data_type = self.parse_data_type()?; let mut options = vec![]; while let Some(option) = self.parse_optional_column_option()? { options.push(option); } let column_position = self.parse_column_position()?; AlterTableOperation::ModifyColumn { col_name, data_type, options, column_position, } } else if self.parse_keyword(Keyword::ALTER) { if self.peek_keyword(Keyword::SORTKEY) { self.prev_token(); return self.parse_alter_sort_key(); } let _ = self.parse_keyword(Keyword::COLUMN); // [ COLUMN ] let column_name = self.parse_identifier()?; let is_postgresql = dialect_of!(self is PostgreSqlDialect); let op: AlterColumnOperation = if self.parse_keywords(&[ Keyword::SET, Keyword::NOT, Keyword::NULL, ]) { AlterColumnOperation::SetNotNull {} } else if self.parse_keywords(&[Keyword::DROP, Keyword::NOT, Keyword::NULL]) { AlterColumnOperation::DropNotNull {} } else if self.parse_keywords(&[Keyword::SET, Keyword::DEFAULT]) { AlterColumnOperation::SetDefault { value: self.parse_expr()?, } } else if self.parse_keywords(&[Keyword::DROP, Keyword::DEFAULT]) { AlterColumnOperation::DropDefault {} } else if self.parse_keywords(&[Keyword::SET, Keyword::DATA, Keyword::TYPE]) { self.parse_set_data_type(true)? } else if self.parse_keyword(Keyword::TYPE) { self.parse_set_data_type(false)? } else if self.parse_keywords(&[Keyword::ADD, Keyword::GENERATED]) { let generated_as = if self.parse_keyword(Keyword::ALWAYS) { Some(GeneratedAs::Always) } else if self.parse_keywords(&[Keyword::BY, Keyword::DEFAULT]) { Some(GeneratedAs::ByDefault) } else { None }; self.expect_keywords(&[Keyword::AS, Keyword::IDENTITY])?; let mut sequence_options: Option> = None; if self.peek_token_ref().token == Token::LParen { self.expect_token(&Token::LParen)?; sequence_options = Some(self.parse_create_sequence_options()?); self.expect_token(&Token::RParen)?; } AlterColumnOperation::AddGenerated { generated_as, sequence_options, } } else { let message = if is_postgresql { "SET/DROP NOT NULL, SET DEFAULT, SET DATA TYPE, or ADD GENERATED after ALTER COLUMN" } else { "SET/DROP NOT NULL, SET DEFAULT, or SET DATA TYPE after ALTER COLUMN" }; return self.expected_ref(message, self.peek_token_ref()); }; AlterTableOperation::AlterColumn { column_name, op } } else if self.parse_keyword(Keyword::SWAP) { self.expect_keyword_is(Keyword::WITH)?; let table_name = self.parse_object_name(false)?; AlterTableOperation::SwapWith { table_name } } else if dialect_of!(self is PostgreSqlDialect | GenericDialect) && self.parse_keywords(&[Keyword::OWNER, Keyword::TO]) { let new_owner = self.parse_owner()?; AlterTableOperation::OwnerTo { new_owner } } else if dialect_of!(self is ClickHouseDialect|GenericDialect) && self.parse_keyword(Keyword::ATTACH) { AlterTableOperation::AttachPartition { partition: self.parse_part_or_partition()?, } } else if dialect_of!(self is ClickHouseDialect|GenericDialect) && self.parse_keyword(Keyword::DETACH) { AlterTableOperation::DetachPartition { partition: self.parse_part_or_partition()?, } } else if dialect_of!(self is ClickHouseDialect|GenericDialect) && self.parse_keyword(Keyword::FREEZE) { let partition = self.parse_part_or_partition()?; let with_name = if self.parse_keyword(Keyword::WITH) { self.expect_keyword_is(Keyword::NAME)?; Some(self.parse_identifier()?) } else { None }; AlterTableOperation::FreezePartition { partition, with_name, } } else if dialect_of!(self is ClickHouseDialect|GenericDialect) && self.parse_keyword(Keyword::UNFREEZE) { let partition = self.parse_part_or_partition()?; let with_name = if self.parse_keyword(Keyword::WITH) { self.expect_keyword_is(Keyword::NAME)?; Some(self.parse_identifier()?) } else { None }; AlterTableOperation::UnfreezePartition { partition, with_name, } } else if self.parse_keywords(&[Keyword::CLUSTER, Keyword::BY]) { self.expect_token(&Token::LParen)?; let exprs = self.parse_comma_separated(|parser| parser.parse_expr())?; self.expect_token(&Token::RParen)?; AlterTableOperation::ClusterBy { exprs } } else if self.parse_keywords(&[Keyword::SUSPEND, Keyword::RECLUSTER]) { AlterTableOperation::SuspendRecluster } else if self.parse_keywords(&[Keyword::RESUME, Keyword::RECLUSTER]) { AlterTableOperation::ResumeRecluster } else if self.parse_keyword(Keyword::LOCK) { let equals = self.consume_token(&Token::Eq); let lock = match self.parse_one_of_keywords(&[ Keyword::DEFAULT, Keyword::EXCLUSIVE, Keyword::NONE, Keyword::SHARED, ]) { Some(Keyword::DEFAULT) => AlterTableLock::Default, Some(Keyword::EXCLUSIVE) => AlterTableLock::Exclusive, Some(Keyword::NONE) => AlterTableLock::None, Some(Keyword::SHARED) => AlterTableLock::Shared, _ => self.expected_ref( "DEFAULT, EXCLUSIVE, NONE or SHARED after LOCK [=]", self.peek_token_ref(), )?, }; AlterTableOperation::Lock { equals, lock } } else if self.parse_keyword(Keyword::ALGORITHM) { let equals = self.consume_token(&Token::Eq); let algorithm = match self.parse_one_of_keywords(&[ Keyword::DEFAULT, Keyword::INSTANT, Keyword::INPLACE, Keyword::COPY, ]) { Some(Keyword::DEFAULT) => AlterTableAlgorithm::Default, Some(Keyword::INSTANT) => AlterTableAlgorithm::Instant, Some(Keyword::INPLACE) => AlterTableAlgorithm::Inplace, Some(Keyword::COPY) => AlterTableAlgorithm::Copy, _ => self.expected_ref( "DEFAULT, INSTANT, INPLACE, or COPY after ALGORITHM [=]", self.peek_token_ref(), )?, }; AlterTableOperation::Algorithm { equals, algorithm } } else if self.parse_keyword(Keyword::AUTO_INCREMENT) { let equals = self.consume_token(&Token::Eq); let value = self.parse_number_value()?; AlterTableOperation::AutoIncrement { equals, value } } else if self.parse_keywords(&[Keyword::REPLICA, Keyword::IDENTITY]) { let identity = if self.parse_keyword(Keyword::NOTHING) { ReplicaIdentity::Nothing } else if self.parse_keyword(Keyword::FULL) { ReplicaIdentity::Full } else if self.parse_keyword(Keyword::DEFAULT) { ReplicaIdentity::Default } else if self.parse_keywords(&[Keyword::USING, Keyword::INDEX]) { ReplicaIdentity::Index(self.parse_identifier()?) } else { return self.expected_ref( "NOTHING, FULL, DEFAULT, or USING INDEX index_name after REPLICA IDENTITY", self.peek_token_ref(), ); }; AlterTableOperation::ReplicaIdentity { identity } } else if self.parse_keywords(&[Keyword::VALIDATE, Keyword::CONSTRAINT]) { let name = self.parse_identifier()?; AlterTableOperation::ValidateConstraint { name } } else { let mut options = self.parse_options_with_keywords(&[Keyword::SET, Keyword::TBLPROPERTIES])?; if !options.is_empty() { AlterTableOperation::SetTblProperties { table_properties: options, } } else { options = self.parse_options(Keyword::SET)?; if !options.is_empty() { AlterTableOperation::SetOptionsParens { options } } else { return self.expected_ref( "ADD, RENAME, PARTITION, SWAP, DROP, REPLICA IDENTITY, SET, or SET TBLPROPERTIES after ALTER TABLE", self.peek_token_ref(), ); } } }; Ok(operation) } fn parse_set_data_type(&mut self, had_set: bool) -> Result { let data_type = self.parse_data_type()?; let using = if self.dialect.supports_alter_column_type_using() && self.parse_keyword(Keyword::USING) { Some(self.parse_expr()?) } else { None }; Ok(AlterColumnOperation::SetDataType { data_type, using, had_set, }) } fn parse_part_or_partition(&mut self) -> Result { let keyword = self.expect_one_of_keywords(&[Keyword::PART, Keyword::PARTITION])?; match keyword { Keyword::PART => Ok(Partition::Part(self.parse_expr()?)), Keyword::PARTITION => Ok(Partition::Expr(self.parse_expr()?)), // unreachable because expect_one_of_keywords used above unexpected_keyword => Err(ParserError::ParserError( format!("Internal parser error: expected any of {{PART, PARTITION}}, got {unexpected_keyword:?}"), )), } } /// Parse an `ALTER ` statement and dispatch to the appropriate alter handler. pub fn parse_alter(&mut self) -> Result { let object_type = self.expect_one_of_keywords(&[ Keyword::VIEW, Keyword::TYPE, Keyword::COLLATION, Keyword::TABLE, Keyword::INDEX, Keyword::FUNCTION, Keyword::AGGREGATE, Keyword::ROLE, Keyword::POLICY, Keyword::CONNECTOR, Keyword::ICEBERG, Keyword::SCHEMA, Keyword::USER, Keyword::OPERATOR, ])?; match object_type { Keyword::SCHEMA => { self.prev_token(); self.prev_token(); self.parse_alter_schema() } Keyword::VIEW => self.parse_alter_view(), Keyword::TYPE => self.parse_alter_type(), Keyword::COLLATION => self.parse_alter_collation().map(Into::into), Keyword::TABLE => self.parse_alter_table(false), Keyword::ICEBERG => { self.expect_keyword(Keyword::TABLE)?; self.parse_alter_table(true) } Keyword::INDEX => { let index_name = self.parse_object_name(false)?; let operation = if self.parse_keyword(Keyword::RENAME) { if self.parse_keyword(Keyword::TO) { let index_name = self.parse_object_name(false)?; AlterIndexOperation::RenameIndex { index_name } } else { return self.expected_ref("TO after RENAME", self.peek_token_ref()); } } else { return self.expected_ref("RENAME after ALTER INDEX", self.peek_token_ref()); }; Ok(Statement::AlterIndex { name: index_name, operation, }) } Keyword::FUNCTION => self.parse_alter_function(AlterFunctionKind::Function), Keyword::AGGREGATE => self.parse_alter_function(AlterFunctionKind::Aggregate), Keyword::OPERATOR => { if self.parse_keyword(Keyword::FAMILY) { self.parse_alter_operator_family().map(Into::into) } else if self.parse_keyword(Keyword::CLASS) { self.parse_alter_operator_class().map(Into::into) } else { self.parse_alter_operator().map(Into::into) } } Keyword::ROLE => self.parse_alter_role(), Keyword::POLICY => self.parse_alter_policy().map(Into::into), Keyword::CONNECTOR => self.parse_alter_connector(), Keyword::USER => self.parse_alter_user().map(Into::into), // unreachable because expect_one_of_keywords used above unexpected_keyword => Err(ParserError::ParserError( format!("Internal parser error: expected any of {{VIEW, TYPE, COLLATION, TABLE, INDEX, FUNCTION, AGGREGATE, ROLE, POLICY, CONNECTOR, ICEBERG, SCHEMA, USER, OPERATOR}}, got {unexpected_keyword:?}"), )), } } fn parse_alter_aggregate_signature( &mut self, ) -> Result<(FunctionDesc, bool, Option>), ParserError> { let name = self.parse_object_name(false)?; self.expect_token(&Token::LParen)?; if self.consume_token(&Token::Mul) { self.expect_token(&Token::RParen)?; return Ok(( FunctionDesc { name, args: Some(vec![]), }, true, None, )); } let args = if self.peek_keyword(Keyword::ORDER) || self.peek_token_ref().token == Token::RParen { vec![] } else { self.parse_comma_separated(Parser::parse_aggregate_function_arg)? }; let aggregate_order_by = if self.parse_keywords(&[Keyword::ORDER, Keyword::BY]) { Some(self.parse_comma_separated(Parser::parse_aggregate_function_arg)?) } else { None }; self.expect_token(&Token::RParen)?; Ok(( FunctionDesc { name, args: Some(args), }, false, aggregate_order_by, )) } fn parse_alter_function_action(&mut self) -> Result, ParserError> { let action = if self.parse_keywords(&[ Keyword::CALLED, Keyword::ON, Keyword::NULL, Keyword::INPUT, ]) { Some(AlterFunctionAction::CalledOnNull( FunctionCalledOnNull::CalledOnNullInput, )) } else if self.parse_keywords(&[ Keyword::RETURNS, Keyword::NULL, Keyword::ON, Keyword::NULL, Keyword::INPUT, ]) { Some(AlterFunctionAction::CalledOnNull( FunctionCalledOnNull::ReturnsNullOnNullInput, )) } else if self.parse_keyword(Keyword::STRICT) { Some(AlterFunctionAction::CalledOnNull( FunctionCalledOnNull::Strict, )) } else if self.parse_keyword(Keyword::IMMUTABLE) { Some(AlterFunctionAction::Behavior(FunctionBehavior::Immutable)) } else if self.parse_keyword(Keyword::STABLE) { Some(AlterFunctionAction::Behavior(FunctionBehavior::Stable)) } else if self.parse_keyword(Keyword::VOLATILE) { Some(AlterFunctionAction::Behavior(FunctionBehavior::Volatile)) } else if self.parse_keyword(Keyword::NOT) { self.expect_keyword(Keyword::LEAKPROOF)?; Some(AlterFunctionAction::Leakproof(false)) } else if self.parse_keyword(Keyword::LEAKPROOF) { Some(AlterFunctionAction::Leakproof(true)) } else if self.parse_keyword(Keyword::EXTERNAL) { self.expect_keyword(Keyword::SECURITY)?; let security = if self.parse_keyword(Keyword::DEFINER) { FunctionSecurity::Definer } else if self.parse_keyword(Keyword::INVOKER) { FunctionSecurity::Invoker } else { return self.expected_ref("DEFINER or INVOKER", self.peek_token_ref()); }; Some(AlterFunctionAction::Security { external: true, security, }) } else if self.parse_keyword(Keyword::SECURITY) { let security = if self.parse_keyword(Keyword::DEFINER) { FunctionSecurity::Definer } else if self.parse_keyword(Keyword::INVOKER) { FunctionSecurity::Invoker } else { return self.expected_ref("DEFINER or INVOKER", self.peek_token_ref()); }; Some(AlterFunctionAction::Security { external: false, security, }) } else if self.parse_keyword(Keyword::PARALLEL) { let parallel = if self.parse_keyword(Keyword::UNSAFE) { FunctionParallel::Unsafe } else if self.parse_keyword(Keyword::RESTRICTED) { FunctionParallel::Restricted } else if self.parse_keyword(Keyword::SAFE) { FunctionParallel::Safe } else { return self .expected_ref("one of UNSAFE | RESTRICTED | SAFE", self.peek_token_ref()); }; Some(AlterFunctionAction::Parallel(parallel)) } else if self.parse_keyword(Keyword::COST) { Some(AlterFunctionAction::Cost(self.parse_number()?)) } else if self.parse_keyword(Keyword::ROWS) { Some(AlterFunctionAction::Rows(self.parse_number()?)) } else if self.parse_keyword(Keyword::SUPPORT) { Some(AlterFunctionAction::Support(self.parse_object_name(false)?)) } else if self.parse_keyword(Keyword::SET) { let name = self.parse_object_name(false)?; let value = if self.parse_keywords(&[Keyword::FROM, Keyword::CURRENT]) { FunctionSetValue::FromCurrent } else { if !self.consume_token(&Token::Eq) && !self.parse_keyword(Keyword::TO) { return self.expected_ref("= or TO", self.peek_token_ref()); } if self.parse_keyword(Keyword::DEFAULT) { FunctionSetValue::Default } else { FunctionSetValue::Values(self.parse_comma_separated(Parser::parse_expr)?) } }; Some(AlterFunctionAction::Set(FunctionDefinitionSetParam { name, value, })) } else if self.parse_keyword(Keyword::RESET) { let reset_config = if self.parse_keyword(Keyword::ALL) { ResetConfig::ALL } else { ResetConfig::ConfigName(self.parse_object_name(false)?) }; Some(AlterFunctionAction::Reset(reset_config)) } else { None }; Ok(action) } fn parse_alter_function_actions( &mut self, ) -> Result<(Vec, bool), ParserError> { let mut actions = vec![]; while let Some(action) = self.parse_alter_function_action()? { actions.push(action); } if actions.is_empty() { return self.expected_ref("at least one ALTER FUNCTION action", self.peek_token_ref()); } let restrict = self.parse_keyword(Keyword::RESTRICT); Ok((actions, restrict)) } /// Parse an `ALTER FUNCTION` or `ALTER AGGREGATE` statement. pub fn parse_alter_function( &mut self, kind: AlterFunctionKind, ) -> Result { let (function, aggregate_star, aggregate_order_by) = match kind { AlterFunctionKind::Function => (self.parse_function_desc()?, false, None), AlterFunctionKind::Aggregate => self.parse_alter_aggregate_signature()?, }; let operation = if self.parse_keywords(&[Keyword::RENAME, Keyword::TO]) { let new_name = self.parse_identifier()?; AlterFunctionOperation::RenameTo { new_name } } else if self.parse_keywords(&[Keyword::OWNER, Keyword::TO]) { AlterFunctionOperation::OwnerTo(self.parse_owner()?) } else if self.parse_keywords(&[Keyword::SET, Keyword::SCHEMA]) { AlterFunctionOperation::SetSchema { schema_name: self.parse_object_name(false)?, } } else if matches!(kind, AlterFunctionKind::Function) && self.parse_keyword(Keyword::NO) { if !self.parse_keyword(Keyword::DEPENDS) { return self.expected_ref("DEPENDS after NO", self.peek_token_ref()); } self.expect_keywords(&[Keyword::ON, Keyword::EXTENSION])?; AlterFunctionOperation::DependsOnExtension { no: true, extension_name: self.parse_object_name(false)?, } } else if matches!(kind, AlterFunctionKind::Function) && self.parse_keyword(Keyword::DEPENDS) { self.expect_keywords(&[Keyword::ON, Keyword::EXTENSION])?; AlterFunctionOperation::DependsOnExtension { no: false, extension_name: self.parse_object_name(false)?, } } else if matches!(kind, AlterFunctionKind::Function) { let (actions, restrict) = self.parse_alter_function_actions()?; AlterFunctionOperation::Actions { actions, restrict } } else { return self.expected_ref( "RENAME TO, OWNER TO, or SET SCHEMA after ALTER AGGREGATE", self.peek_token_ref(), ); }; Ok(Statement::AlterFunction(AlterFunction { kind, function, aggregate_order_by, aggregate_star, operation, })) } /// Parse a [Statement::AlterTable] pub fn parse_alter_table(&mut self, iceberg: bool) -> Result { let if_exists = self.parse_keywords(&[Keyword::IF, Keyword::EXISTS]); let only = self.parse_keyword(Keyword::ONLY); // [ ONLY ] let table_name = self.parse_object_name(false)?; let on_cluster = self.parse_optional_on_cluster()?; let operations = self.parse_comma_separated(Parser::parse_alter_table_operation)?; let mut location = None; if self.parse_keyword(Keyword::LOCATION) { location = Some(HiveSetLocation { has_set: false, location: self.parse_identifier()?, }); } else if self.parse_keywords(&[Keyword::SET, Keyword::LOCATION]) { location = Some(HiveSetLocation { has_set: true, location: self.parse_identifier()?, }); } let end_token = if self.peek_token_ref().token == Token::SemiColon { self.peek_token_ref().clone() } else { self.get_current_token().clone() }; Ok(AlterTable { name: table_name, if_exists, only, operations, location, on_cluster, table_type: if iceberg { Some(AlterTableType::Iceberg) } else { None }, end_token: AttachedToken(end_token), } .into()) } /// Parse an `ALTER VIEW` statement. pub fn parse_alter_view(&mut self) -> Result { let name = self.parse_object_name(false)?; let columns = self.parse_parenthesized_column_list(Optional, false)?; let with_options = self.parse_options(Keyword::WITH)?; self.expect_keyword_is(Keyword::AS)?; let query = self.parse_query()?; Ok(Statement::AlterView { name, columns, query, with_options, }) } /// Parse a [Statement::AlterType] pub fn parse_alter_type(&mut self) -> Result { let name = self.parse_object_name(false)?; if self.parse_keywords(&[Keyword::RENAME, Keyword::TO]) { let new_name = self.parse_identifier()?; Ok(Statement::AlterType(AlterType { name, operation: AlterTypeOperation::Rename(AlterTypeRename { new_name }), })) } else if self.parse_keywords(&[Keyword::ADD, Keyword::VALUE]) { let if_not_exists = self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]); let new_enum_value = self.parse_identifier()?; let position = if self.parse_keyword(Keyword::BEFORE) { Some(AlterTypeAddValuePosition::Before(self.parse_identifier()?)) } else if self.parse_keyword(Keyword::AFTER) { Some(AlterTypeAddValuePosition::After(self.parse_identifier()?)) } else { None }; Ok(Statement::AlterType(AlterType { name, operation: AlterTypeOperation::AddValue(AlterTypeAddValue { if_not_exists, value: new_enum_value, position, }), })) } else if self.parse_keywords(&[Keyword::RENAME, Keyword::VALUE]) { let existing_enum_value = self.parse_identifier()?; self.expect_keyword(Keyword::TO)?; let new_enum_value = self.parse_identifier()?; Ok(Statement::AlterType(AlterType { name, operation: AlterTypeOperation::RenameValue(AlterTypeRenameValue { from: existing_enum_value, to: new_enum_value, }), })) } else { self.expected_ref( "{RENAME TO | { RENAME | ADD } VALUE}", self.peek_token_ref(), ) } } /// Parse a [Statement::AlterCollation]. /// /// [PostgreSQL Documentation](https://www.postgresql.org/docs/current/sql-altercollation.html) pub fn parse_alter_collation(&mut self) -> Result { let name = self.parse_object_name(false)?; let operation = if self.parse_keywords(&[Keyword::RENAME, Keyword::TO]) { AlterCollationOperation::RenameTo { new_name: self.parse_identifier()?, } } else if self.parse_keywords(&[Keyword::OWNER, Keyword::TO]) { AlterCollationOperation::OwnerTo(self.parse_owner()?) } else if self.parse_keywords(&[Keyword::SET, Keyword::SCHEMA]) { AlterCollationOperation::SetSchema { schema_name: self.parse_object_name(false)?, } } else if self.parse_keywords(&[Keyword::REFRESH, Keyword::VERSION]) { AlterCollationOperation::RefreshVersion } else { return self.expected_ref( "RENAME TO, OWNER TO, SET SCHEMA, or REFRESH VERSION after ALTER COLLATION", self.peek_token_ref(), ); }; Ok(AlterCollation { name, operation }) } /// Parse a [Statement::AlterOperator] /// /// [PostgreSQL Documentation](https://www.postgresql.org/docs/current/sql-alteroperator.html) pub fn parse_alter_operator(&mut self) -> Result { let name = self.parse_operator_name()?; // Parse (left_type, right_type) self.expect_token(&Token::LParen)?; let left_type = if self.parse_keyword(Keyword::NONE) { None } else { Some(self.parse_data_type()?) }; self.expect_token(&Token::Comma)?; let right_type = self.parse_data_type()?; self.expect_token(&Token::RParen)?; // Parse the operation let operation = if self.parse_keywords(&[Keyword::OWNER, Keyword::TO]) { let owner = if self.parse_keyword(Keyword::CURRENT_ROLE) { Owner::CurrentRole } else if self.parse_keyword(Keyword::CURRENT_USER) { Owner::CurrentUser } else if self.parse_keyword(Keyword::SESSION_USER) { Owner::SessionUser } else { Owner::Ident(self.parse_identifier()?) }; AlterOperatorOperation::OwnerTo(owner) } else if self.parse_keywords(&[Keyword::SET, Keyword::SCHEMA]) { let schema_name = self.parse_object_name(false)?; AlterOperatorOperation::SetSchema { schema_name } } else if self.parse_keyword(Keyword::SET) { self.expect_token(&Token::LParen)?; let mut options = Vec::new(); loop { let keyword = self.expect_one_of_keywords(&[ Keyword::RESTRICT, Keyword::JOIN, Keyword::COMMUTATOR, Keyword::NEGATOR, Keyword::HASHES, Keyword::MERGES, ])?; match keyword { Keyword::RESTRICT => { self.expect_token(&Token::Eq)?; let proc_name = if self.parse_keyword(Keyword::NONE) { None } else { Some(self.parse_object_name(false)?) }; options.push(OperatorOption::Restrict(proc_name)); } Keyword::JOIN => { self.expect_token(&Token::Eq)?; let proc_name = if self.parse_keyword(Keyword::NONE) { None } else { Some(self.parse_object_name(false)?) }; options.push(OperatorOption::Join(proc_name)); } Keyword::COMMUTATOR => { self.expect_token(&Token::Eq)?; let op_name = self.parse_operator_name()?; options.push(OperatorOption::Commutator(op_name)); } Keyword::NEGATOR => { self.expect_token(&Token::Eq)?; let op_name = self.parse_operator_name()?; options.push(OperatorOption::Negator(op_name)); } Keyword::HASHES => { options.push(OperatorOption::Hashes); } Keyword::MERGES => { options.push(OperatorOption::Merges); } unexpected_keyword => return Err(ParserError::ParserError( format!("Internal parser error: unexpected keyword `{unexpected_keyword}` in operator option"), )), } if !self.consume_token(&Token::Comma) { break; } } self.expect_token(&Token::RParen)?; AlterOperatorOperation::Set { options } } else { return self.expected_ref( "OWNER TO, SET SCHEMA, or SET after ALTER OPERATOR", self.peek_token_ref(), ); }; Ok(AlterOperator { name, left_type, right_type, operation, }) } /// Parse an operator item for ALTER OPERATOR FAMILY ADD operations fn parse_operator_family_add_operator(&mut self) -> Result { let strategy_number = self.parse_literal_uint()?; let operator_name = self.parse_operator_name()?; // Operator argument types (required for ALTER OPERATOR FAMILY) self.expect_token(&Token::LParen)?; let op_types = self.parse_comma_separated(Parser::parse_data_type)?; self.expect_token(&Token::RParen)?; // Optional purpose let purpose = if self.parse_keyword(Keyword::FOR) { if self.parse_keyword(Keyword::SEARCH) { Some(OperatorPurpose::ForSearch) } else if self.parse_keywords(&[Keyword::ORDER, Keyword::BY]) { let sort_family = self.parse_object_name(false)?; Some(OperatorPurpose::ForOrderBy { sort_family }) } else { return self.expected_ref("SEARCH or ORDER BY after FOR", self.peek_token_ref()); } } else { None }; Ok(OperatorFamilyItem::Operator { strategy_number, operator_name, op_types, purpose, }) } /// Parse a function item for ALTER OPERATOR FAMILY ADD operations fn parse_operator_family_add_function(&mut self) -> Result { let support_number = self.parse_literal_uint()?; // Optional operator types let op_types = if self.consume_token(&Token::LParen) && self.peek_token_ref().token != Token::RParen { let types = self.parse_comma_separated(Parser::parse_data_type)?; self.expect_token(&Token::RParen)?; Some(types) } else if self.consume_token(&Token::LParen) { self.expect_token(&Token::RParen)?; Some(vec![]) } else { None }; let function_name = self.parse_object_name(false)?; // Function argument types let argument_types = if self.consume_token(&Token::LParen) { if self.peek_token_ref().token == Token::RParen { self.expect_token(&Token::RParen)?; vec![] } else { let types = self.parse_comma_separated(Parser::parse_data_type)?; self.expect_token(&Token::RParen)?; types } } else { vec![] }; Ok(OperatorFamilyItem::Function { support_number, op_types, function_name, argument_types, }) } /// Parse an operator item for ALTER OPERATOR FAMILY DROP operations fn parse_operator_family_drop_operator( &mut self, ) -> Result { let strategy_number = self.parse_literal_uint()?; // Operator argument types (required for DROP) self.expect_token(&Token::LParen)?; let op_types = self.parse_comma_separated(Parser::parse_data_type)?; self.expect_token(&Token::RParen)?; Ok(OperatorFamilyDropItem::Operator { strategy_number, op_types, }) } /// Parse a function item for ALTER OPERATOR FAMILY DROP operations fn parse_operator_family_drop_function( &mut self, ) -> Result { let support_number = self.parse_literal_uint()?; // Operator types (required for DROP) self.expect_token(&Token::LParen)?; let op_types = self.parse_comma_separated(Parser::parse_data_type)?; self.expect_token(&Token::RParen)?; Ok(OperatorFamilyDropItem::Function { support_number, op_types, }) } /// Parse an operator family item for ADD operations (dispatches to operator or function parsing) fn parse_operator_family_add_item(&mut self) -> Result { if self.parse_keyword(Keyword::OPERATOR) { self.parse_operator_family_add_operator() } else if self.parse_keyword(Keyword::FUNCTION) { self.parse_operator_family_add_function() } else { self.expected_ref("OPERATOR or FUNCTION", self.peek_token_ref()) } } /// Parse an operator family item for DROP operations (dispatches to operator or function parsing) fn parse_operator_family_drop_item(&mut self) -> Result { if self.parse_keyword(Keyword::OPERATOR) { self.parse_operator_family_drop_operator() } else if self.parse_keyword(Keyword::FUNCTION) { self.parse_operator_family_drop_function() } else { self.expected_ref("OPERATOR or FUNCTION", self.peek_token_ref()) } } /// Parse a [Statement::AlterOperatorFamily] /// See pub fn parse_alter_operator_family(&mut self) -> Result { let name = self.parse_object_name(false)?; self.expect_keyword(Keyword::USING)?; let using = self.parse_identifier()?; let operation = if self.parse_keyword(Keyword::ADD) { let items = self.parse_comma_separated(Parser::parse_operator_family_add_item)?; AlterOperatorFamilyOperation::Add { items } } else if self.parse_keyword(Keyword::DROP) { let items = self.parse_comma_separated(Parser::parse_operator_family_drop_item)?; AlterOperatorFamilyOperation::Drop { items } } else if self.parse_keywords(&[Keyword::RENAME, Keyword::TO]) { let new_name = self.parse_object_name(false)?; AlterOperatorFamilyOperation::RenameTo { new_name } } else if self.parse_keywords(&[Keyword::OWNER, Keyword::TO]) { let owner = self.parse_owner()?; AlterOperatorFamilyOperation::OwnerTo(owner) } else if self.parse_keywords(&[Keyword::SET, Keyword::SCHEMA]) { let schema_name = self.parse_object_name(false)?; AlterOperatorFamilyOperation::SetSchema { schema_name } } else { return self.expected_ref( "ADD, DROP, RENAME TO, OWNER TO, or SET SCHEMA after ALTER OPERATOR FAMILY", self.peek_token_ref(), ); }; Ok(AlterOperatorFamily { name, using, operation, }) } /// Parse an `ALTER OPERATOR CLASS` statement. /// /// Handles operations like `RENAME TO`, `OWNER TO`, and `SET SCHEMA`. pub fn parse_alter_operator_class(&mut self) -> Result { let name = self.parse_object_name(false)?; self.expect_keyword(Keyword::USING)?; let using = self.parse_identifier()?; let operation = if self.parse_keywords(&[Keyword::RENAME, Keyword::TO]) { let new_name = self.parse_object_name(false)?; AlterOperatorClassOperation::RenameTo { new_name } } else if self.parse_keywords(&[Keyword::OWNER, Keyword::TO]) { let owner = self.parse_owner()?; AlterOperatorClassOperation::OwnerTo(owner) } else if self.parse_keywords(&[Keyword::SET, Keyword::SCHEMA]) { let schema_name = self.parse_object_name(false)?; AlterOperatorClassOperation::SetSchema { schema_name } } else { return self.expected_ref( "RENAME TO, OWNER TO, or SET SCHEMA after ALTER OPERATOR CLASS", self.peek_token_ref(), ); }; Ok(AlterOperatorClass { name, using, operation, }) } /// Parse an `ALTER SCHEMA` statement. /// /// Supports operations such as setting options, renaming, adding/dropping replicas, and changing owner. pub fn parse_alter_schema(&mut self) -> Result { self.expect_keywords(&[Keyword::ALTER, Keyword::SCHEMA])?; let if_exists = self.parse_keywords(&[Keyword::IF, Keyword::EXISTS]); let name = self.parse_object_name(false)?; let operation = if self.parse_keywords(&[Keyword::SET, Keyword::OPTIONS]) { self.prev_token(); let options = self.parse_options(Keyword::OPTIONS)?; AlterSchemaOperation::SetOptionsParens { options } } else if self.parse_keywords(&[Keyword::SET, Keyword::DEFAULT, Keyword::COLLATE]) { let collate = self.parse_expr()?; AlterSchemaOperation::SetDefaultCollate { collate } } else if self.parse_keywords(&[Keyword::ADD, Keyword::REPLICA]) { let replica = self.parse_identifier()?; let options = if self.peek_keyword(Keyword::OPTIONS) { Some(self.parse_options(Keyword::OPTIONS)?) } else { None }; AlterSchemaOperation::AddReplica { replica, options } } else if self.parse_keywords(&[Keyword::DROP, Keyword::REPLICA]) { let replica = self.parse_identifier()?; AlterSchemaOperation::DropReplica { replica } } else if self.parse_keywords(&[Keyword::RENAME, Keyword::TO]) { let new_name = self.parse_object_name(false)?; AlterSchemaOperation::Rename { name: new_name } } else if self.parse_keywords(&[Keyword::OWNER, Keyword::TO]) { let owner = self.parse_owner()?; AlterSchemaOperation::OwnerTo { owner } } else { return self.expected_ref("ALTER SCHEMA operation", self.peek_token_ref()); }; Ok(Statement::AlterSchema(AlterSchema { name, if_exists, operations: vec![operation], })) } /// Parse a `CALL procedure_name(arg1, arg2, ...)` /// or `CALL procedure_name` statement pub fn parse_call(&mut self) -> Result { let object_name = self.parse_object_name(false)?; if self.peek_token_ref().token == Token::LParen { match self.parse_function(object_name)? { Expr::Function(f) => Ok(Statement::Call(f)), other => parser_err!( format!("Expected a simple procedure call but found: {other}"), self.peek_token_ref().span.start ), } } else { Ok(Statement::Call(Function { name: object_name, uses_odbc_syntax: false, parameters: FunctionArguments::None, args: FunctionArguments::None, over: None, filter: None, null_treatment: None, within_group: vec![], })) } } /// Parse a copy statement pub fn parse_copy(&mut self) -> Result { let source; if self.consume_token(&Token::LParen) { source = CopySource::Query(self.parse_query()?); self.expect_token(&Token::RParen)?; } else { let table_name = self.parse_object_name(false)?; let columns = self.parse_parenthesized_column_list(Optional, false)?; source = CopySource::Table { table_name, columns, }; } let to = match self.parse_one_of_keywords(&[Keyword::FROM, Keyword::TO]) { Some(Keyword::FROM) => false, Some(Keyword::TO) => true, _ => self.expected_ref("FROM or TO", self.peek_token_ref())?, }; if !to { // Use a separate if statement to prevent Rust compiler from complaining about // "if statement in this position is unstable: https://github.com/rust-lang/rust/issues/53667" if let CopySource::Query(_) = source { return Err(ParserError::ParserError( "COPY ... FROM does not support query as a source".to_string(), )); } } let target = if self.parse_keyword(Keyword::STDIN) { CopyTarget::Stdin } else if self.parse_keyword(Keyword::STDOUT) { CopyTarget::Stdout } else if self.parse_keyword(Keyword::PROGRAM) { CopyTarget::Program { command: self.parse_literal_string()?, } } else { CopyTarget::File { filename: self.parse_literal_string()?, } }; let _ = self.parse_keyword(Keyword::WITH); // [ WITH ] let mut options = vec![]; if self.consume_token(&Token::LParen) { options = self.parse_comma_separated(Parser::parse_copy_option)?; self.expect_token(&Token::RParen)?; } let mut legacy_options = vec![]; while let Some(opt) = self.maybe_parse(|parser| parser.parse_copy_legacy_option())? { legacy_options.push(opt); } let values = if matches!(target, CopyTarget::Stdin) && self.peek_token_ref().token != Token::EOF { self.expect_token(&Token::SemiColon)?; self.parse_tsv() } else { vec![] }; Ok(Statement::Copy { source, to, target, options, legacy_options, values, }) } /// Parse [Statement::Open] fn parse_open(&mut self) -> Result { self.expect_keyword(Keyword::OPEN)?; Ok(Statement::Open(OpenStatement { cursor_name: self.parse_identifier()?, })) } /// Parse a `CLOSE` cursor statement. pub fn parse_close(&mut self) -> Result { let cursor = if self.parse_keyword(Keyword::ALL) { CloseCursor::All } else { let name = self.parse_identifier()?; CloseCursor::Specific { name } }; Ok(Statement::Close { cursor }) } fn parse_copy_option(&mut self) -> Result { let ret = match self.parse_one_of_keywords(&[ Keyword::FORMAT, Keyword::FREEZE, Keyword::DELIMITER, Keyword::NULL, Keyword::HEADER, Keyword::QUOTE, Keyword::ESCAPE, Keyword::FORCE_QUOTE, Keyword::FORCE_NOT_NULL, Keyword::FORCE_NULL, Keyword::ENCODING, ]) { Some(Keyword::FORMAT) => CopyOption::Format(self.parse_identifier()?), Some(Keyword::FREEZE) => CopyOption::Freeze(!matches!( self.parse_one_of_keywords(&[Keyword::TRUE, Keyword::FALSE]), Some(Keyword::FALSE) )), Some(Keyword::DELIMITER) => CopyOption::Delimiter(self.parse_literal_char()?), Some(Keyword::NULL) => CopyOption::Null(self.parse_literal_string()?), Some(Keyword::HEADER) => CopyOption::Header(!matches!( self.parse_one_of_keywords(&[Keyword::TRUE, Keyword::FALSE]), Some(Keyword::FALSE) )), Some(Keyword::QUOTE) => CopyOption::Quote(self.parse_literal_char()?), Some(Keyword::ESCAPE) => CopyOption::Escape(self.parse_literal_char()?), Some(Keyword::FORCE_QUOTE) => { CopyOption::ForceQuote(self.parse_parenthesized_column_list(Mandatory, false)?) } Some(Keyword::FORCE_NOT_NULL) => { CopyOption::ForceNotNull(self.parse_parenthesized_column_list(Mandatory, false)?) } Some(Keyword::FORCE_NULL) => { CopyOption::ForceNull(self.parse_parenthesized_column_list(Mandatory, false)?) } Some(Keyword::ENCODING) => CopyOption::Encoding(self.parse_literal_string()?), _ => self.expected_ref("option", self.peek_token_ref())?, }; Ok(ret) } fn parse_copy_legacy_option(&mut self) -> Result { // FORMAT \[ AS \] is optional if self.parse_keyword(Keyword::FORMAT) { let _ = self.parse_keyword(Keyword::AS); } let ret = match self.parse_one_of_keywords(&[ Keyword::ACCEPTANYDATE, Keyword::ACCEPTINVCHARS, Keyword::ADDQUOTES, Keyword::ALLOWOVERWRITE, Keyword::BINARY, Keyword::BLANKSASNULL, Keyword::BZIP2, Keyword::CLEANPATH, Keyword::COMPUPDATE, Keyword::CREDENTIALS, Keyword::CSV, Keyword::DATEFORMAT, Keyword::DELIMITER, Keyword::EMPTYASNULL, Keyword::ENCRYPTED, Keyword::ESCAPE, Keyword::EXTENSION, Keyword::FIXEDWIDTH, Keyword::GZIP, Keyword::HEADER, Keyword::IAM_ROLE, Keyword::IGNOREHEADER, Keyword::JSON, Keyword::MANIFEST, Keyword::MAXFILESIZE, Keyword::NULL, Keyword::PARALLEL, Keyword::PARQUET, Keyword::PARTITION, Keyword::REGION, Keyword::REMOVEQUOTES, Keyword::ROWGROUPSIZE, Keyword::STATUPDATE, Keyword::TIMEFORMAT, Keyword::TRUNCATECOLUMNS, Keyword::ZSTD, ]) { Some(Keyword::ACCEPTANYDATE) => CopyLegacyOption::AcceptAnyDate, Some(Keyword::ACCEPTINVCHARS) => { let _ = self.parse_keyword(Keyword::AS); // [ AS ] let ch = if matches!(self.peek_token_ref().token, Token::SingleQuotedString(_)) { Some(self.parse_literal_string()?) } else { None }; CopyLegacyOption::AcceptInvChars(ch) } Some(Keyword::ADDQUOTES) => CopyLegacyOption::AddQuotes, Some(Keyword::ALLOWOVERWRITE) => CopyLegacyOption::AllowOverwrite, Some(Keyword::BINARY) => CopyLegacyOption::Binary, Some(Keyword::BLANKSASNULL) => CopyLegacyOption::BlankAsNull, Some(Keyword::BZIP2) => CopyLegacyOption::Bzip2, Some(Keyword::CLEANPATH) => CopyLegacyOption::CleanPath, Some(Keyword::COMPUPDATE) => { let preset = self.parse_keyword(Keyword::PRESET); let enabled = match self.parse_one_of_keywords(&[ Keyword::TRUE, Keyword::FALSE, Keyword::ON, Keyword::OFF, ]) { Some(Keyword::TRUE) | Some(Keyword::ON) => Some(true), Some(Keyword::FALSE) | Some(Keyword::OFF) => Some(false), _ => None, }; CopyLegacyOption::CompUpdate { preset, enabled } } Some(Keyword::CREDENTIALS) => { CopyLegacyOption::Credentials(self.parse_literal_string()?) } Some(Keyword::CSV) => CopyLegacyOption::Csv({ let mut opts = vec![]; while let Some(opt) = self.maybe_parse(|parser| parser.parse_copy_legacy_csv_option())? { opts.push(opt); } opts }), Some(Keyword::DATEFORMAT) => { let _ = self.parse_keyword(Keyword::AS); let fmt = if matches!(self.peek_token_ref().token, Token::SingleQuotedString(_)) { Some(self.parse_literal_string()?) } else { None }; CopyLegacyOption::DateFormat(fmt) } Some(Keyword::DELIMITER) => { let _ = self.parse_keyword(Keyword::AS); CopyLegacyOption::Delimiter(self.parse_literal_char()?) } Some(Keyword::EMPTYASNULL) => CopyLegacyOption::EmptyAsNull, Some(Keyword::ENCRYPTED) => { let auto = self.parse_keyword(Keyword::AUTO); CopyLegacyOption::Encrypted { auto } } Some(Keyword::ESCAPE) => CopyLegacyOption::Escape, Some(Keyword::EXTENSION) => { let ext = self.parse_literal_string()?; CopyLegacyOption::Extension(ext) } Some(Keyword::FIXEDWIDTH) => { let spec = self.parse_literal_string()?; CopyLegacyOption::FixedWidth(spec) } Some(Keyword::GZIP) => CopyLegacyOption::Gzip, Some(Keyword::HEADER) => CopyLegacyOption::Header, Some(Keyword::IAM_ROLE) => CopyLegacyOption::IamRole(self.parse_iam_role_kind()?), Some(Keyword::IGNOREHEADER) => { let _ = self.parse_keyword(Keyword::AS); let num_rows = self.parse_literal_uint()?; CopyLegacyOption::IgnoreHeader(num_rows) } Some(Keyword::JSON) => { let _ = self.parse_keyword(Keyword::AS); let fmt = if matches!(self.peek_token_ref().token, Token::SingleQuotedString(_)) { Some(self.parse_literal_string()?) } else { None }; CopyLegacyOption::Json(fmt) } Some(Keyword::MANIFEST) => { let verbose = self.parse_keyword(Keyword::VERBOSE); CopyLegacyOption::Manifest { verbose } } Some(Keyword::MAXFILESIZE) => { let _ = self.parse_keyword(Keyword::AS); let size = self.parse_number_value()?; let unit = match self.parse_one_of_keywords(&[Keyword::MB, Keyword::GB]) { Some(Keyword::MB) => Some(FileSizeUnit::MB), Some(Keyword::GB) => Some(FileSizeUnit::GB), _ => None, }; CopyLegacyOption::MaxFileSize(FileSize { size, unit }) } Some(Keyword::NULL) => { let _ = self.parse_keyword(Keyword::AS); CopyLegacyOption::Null(self.parse_literal_string()?) } Some(Keyword::PARALLEL) => { let enabled = match self.parse_one_of_keywords(&[ Keyword::TRUE, Keyword::FALSE, Keyword::ON, Keyword::OFF, ]) { Some(Keyword::TRUE) | Some(Keyword::ON) => Some(true), Some(Keyword::FALSE) | Some(Keyword::OFF) => Some(false), _ => None, }; CopyLegacyOption::Parallel(enabled) } Some(Keyword::PARQUET) => CopyLegacyOption::Parquet, Some(Keyword::PARTITION) => { self.expect_keyword(Keyword::BY)?; let columns = self.parse_parenthesized_column_list(IsOptional::Mandatory, false)?; let include = self.parse_keyword(Keyword::INCLUDE); CopyLegacyOption::PartitionBy(UnloadPartitionBy { columns, include }) } Some(Keyword::REGION) => { let _ = self.parse_keyword(Keyword::AS); let region = self.parse_literal_string()?; CopyLegacyOption::Region(region) } Some(Keyword::REMOVEQUOTES) => CopyLegacyOption::RemoveQuotes, Some(Keyword::ROWGROUPSIZE) => { let _ = self.parse_keyword(Keyword::AS); let file_size = self.parse_file_size()?; CopyLegacyOption::RowGroupSize(file_size) } Some(Keyword::STATUPDATE) => { let enabled = match self.parse_one_of_keywords(&[ Keyword::TRUE, Keyword::FALSE, Keyword::ON, Keyword::OFF, ]) { Some(Keyword::TRUE) | Some(Keyword::ON) => Some(true), Some(Keyword::FALSE) | Some(Keyword::OFF) => Some(false), _ => None, }; CopyLegacyOption::StatUpdate(enabled) } Some(Keyword::TIMEFORMAT) => { let _ = self.parse_keyword(Keyword::AS); let fmt = if matches!(self.peek_token_ref().token, Token::SingleQuotedString(_)) { Some(self.parse_literal_string()?) } else { None }; CopyLegacyOption::TimeFormat(fmt) } Some(Keyword::TRUNCATECOLUMNS) => CopyLegacyOption::TruncateColumns, Some(Keyword::ZSTD) => CopyLegacyOption::Zstd, _ => self.expected_ref("option", self.peek_token_ref())?, }; Ok(ret) } fn parse_file_size(&mut self) -> Result { let size = self.parse_number_value()?; let unit = self.maybe_parse_file_size_unit(); Ok(FileSize { size, unit }) } fn maybe_parse_file_size_unit(&mut self) -> Option { match self.parse_one_of_keywords(&[Keyword::MB, Keyword::GB]) { Some(Keyword::MB) => Some(FileSizeUnit::MB), Some(Keyword::GB) => Some(FileSizeUnit::GB), _ => None, } } fn parse_iam_role_kind(&mut self) -> Result { if self.parse_keyword(Keyword::DEFAULT) { Ok(IamRoleKind::Default) } else { let arn = self.parse_literal_string()?; Ok(IamRoleKind::Arn(arn)) } } fn parse_copy_legacy_csv_option(&mut self) -> Result { let ret = match self.parse_one_of_keywords(&[ Keyword::HEADER, Keyword::QUOTE, Keyword::ESCAPE, Keyword::FORCE, ]) { Some(Keyword::HEADER) => CopyLegacyCsvOption::Header, Some(Keyword::QUOTE) => { let _ = self.parse_keyword(Keyword::AS); // [ AS ] CopyLegacyCsvOption::Quote(self.parse_literal_char()?) } Some(Keyword::ESCAPE) => { let _ = self.parse_keyword(Keyword::AS); // [ AS ] CopyLegacyCsvOption::Escape(self.parse_literal_char()?) } Some(Keyword::FORCE) if self.parse_keywords(&[Keyword::NOT, Keyword::NULL]) => { CopyLegacyCsvOption::ForceNotNull( self.parse_comma_separated(|p| p.parse_identifier())?, ) } Some(Keyword::FORCE) if self.parse_keywords(&[Keyword::QUOTE]) => { CopyLegacyCsvOption::ForceQuote( self.parse_comma_separated(|p| p.parse_identifier())?, ) } _ => self.expected_ref("csv option", self.peek_token_ref())?, }; Ok(ret) } fn parse_literal_char(&mut self) -> Result { let s = self.parse_literal_string()?; if s.len() != 1 { let loc = self .tokens .get(self.index - 1) .map_or(Location { line: 0, column: 0 }, |t| t.span.start); return parser_err!(format!("Expect a char, found {s:?}"), loc); } Ok(s.chars().next().unwrap()) } /// Parse a tab separated values in /// COPY payload pub fn parse_tsv(&mut self) -> Vec> { self.parse_tab_value() } /// Parse a single tab-separated value row used by `COPY` payload parsing. pub fn parse_tab_value(&mut self) -> Vec> { let mut values = vec![]; let mut content = String::new(); while let Some(t) = self.next_token_no_skip().map(|t| &t.token) { match t { Token::Whitespace(Whitespace::Tab) => { values.push(Some(core::mem::take(&mut content))); } Token::Whitespace(Whitespace::Newline) => { values.push(Some(core::mem::take(&mut content))); } Token::Backslash => { if self.consume_token(&Token::Period) { return values; } if let Token::Word(w) = self.next_token().token { if w.value == "N" { values.push(None); } } } _ => { content.push_str(&t.to_string()); } } } values } /// Parse a literal value (numbers, strings, date/time, booleans) pub fn parse_value(&mut self) -> Result { let next_token = self.next_token(); let span = next_token.span; let ok_value = |value: Value| Ok(value.with_span(span)); match next_token.token { Token::Word(w) => match w.keyword { Keyword::TRUE if self.dialect.supports_boolean_literals() => { ok_value(Value::Boolean(true)) } Keyword::FALSE if self.dialect.supports_boolean_literals() => { ok_value(Value::Boolean(false)) } Keyword::NULL => ok_value(Value::Null), Keyword::NoKeyword if w.quote_style.is_some() => match w.quote_style { Some('"') => ok_value(Value::DoubleQuotedString(w.value)), Some('\'') => ok_value(Value::SingleQuotedString(w.value)), _ => self.expected( "A value?", TokenWithSpan { token: Token::Word(w), span, }, )?, }, _ => self.expected( "a concrete value", TokenWithSpan { token: Token::Word(w), span, }, ), }, // The call to n.parse() returns a bigdecimal when the // bigdecimal feature is enabled, and is otherwise a no-op // (i.e., it returns the input string). Token::Number(n, l) => ok_value(Value::Number(Self::parse(n, span.start)?, l)), Token::SingleQuotedString(ref s) => ok_value(Value::SingleQuotedString( self.maybe_concat_string_literal(s.to_string()), )), Token::DoubleQuotedString(ref s) => ok_value(Value::DoubleQuotedString( self.maybe_concat_string_literal(s.to_string()), )), Token::TripleSingleQuotedString(ref s) => { ok_value(Value::TripleSingleQuotedString(s.to_string())) } Token::TripleDoubleQuotedString(ref s) => { ok_value(Value::TripleDoubleQuotedString(s.to_string())) } Token::DollarQuotedString(ref s) => ok_value(Value::DollarQuotedString(s.clone())), Token::SingleQuotedByteStringLiteral(ref s) => { ok_value(Value::SingleQuotedByteStringLiteral(s.clone())) } Token::DoubleQuotedByteStringLiteral(ref s) => { ok_value(Value::DoubleQuotedByteStringLiteral(s.clone())) } Token::TripleSingleQuotedByteStringLiteral(ref s) => { ok_value(Value::TripleSingleQuotedByteStringLiteral(s.clone())) } Token::TripleDoubleQuotedByteStringLiteral(ref s) => { ok_value(Value::TripleDoubleQuotedByteStringLiteral(s.clone())) } Token::SingleQuotedRawStringLiteral(ref s) => { ok_value(Value::SingleQuotedRawStringLiteral(s.clone())) } Token::DoubleQuotedRawStringLiteral(ref s) => { ok_value(Value::DoubleQuotedRawStringLiteral(s.clone())) } Token::TripleSingleQuotedRawStringLiteral(ref s) => { ok_value(Value::TripleSingleQuotedRawStringLiteral(s.clone())) } Token::TripleDoubleQuotedRawStringLiteral(ref s) => { ok_value(Value::TripleDoubleQuotedRawStringLiteral(s.clone())) } Token::NationalStringLiteral(ref s) => { ok_value(Value::NationalStringLiteral(s.to_string())) } Token::QuoteDelimitedStringLiteral(v) => { ok_value(Value::QuoteDelimitedStringLiteral(v)) } Token::NationalQuoteDelimitedStringLiteral(v) => { ok_value(Value::NationalQuoteDelimitedStringLiteral(v)) } Token::EscapedStringLiteral(ref s) => { ok_value(Value::EscapedStringLiteral(s.to_string())) } Token::UnicodeStringLiteral(ref s) => { ok_value(Value::UnicodeStringLiteral(s.to_string())) } Token::HexStringLiteral(ref s) => ok_value(Value::HexStringLiteral(s.to_string())), Token::Placeholder(ref s) => ok_value(Value::Placeholder(s.to_string())), tok @ Token::Colon | tok @ Token::AtSign => { // 1. Not calling self.parse_identifier(false)? // because only in placeholder we want to check // numbers as idfentifies. This because snowflake // allows numbers as placeholders // 2. Not calling self.next_token() to enforce `tok` // be followed immediately by a word/number, ie. // without any whitespace in between let next_token = self.next_token_no_skip().unwrap_or(&EOF_TOKEN).clone(); let ident = match next_token.token { Token::Word(w) => Ok(w.into_ident(next_token.span)), Token::Number(w, false) => Ok(Ident::with_span(next_token.span, w)), _ => self.expected("placeholder", next_token), }?; Ok(Value::Placeholder(format!("{tok}{}", ident.value)) .with_span(Span::new(span.start, ident.span.end))) } unexpected => self.expected( "a value", TokenWithSpan { token: unexpected, span, }, ), } } fn maybe_concat_string_literal(&mut self, mut str: String) -> String { if self.dialect.supports_string_literal_concatenation() { while let Token::SingleQuotedString(ref s) | Token::DoubleQuotedString(ref s) = self.peek_token_ref().token { str.push_str(s); self.advance_token(); } } else if self .dialect .supports_string_literal_concatenation_with_newline() { // We are iterating over tokens including whitespaces, to identify // string literals separated by newlines so we can concatenate them. let mut after_newline = false; loop { match self.peek_token_no_skip().token { Token::Whitespace(Whitespace::Newline) => { after_newline = true; self.next_token_no_skip(); } Token::Whitespace(_) => { self.next_token_no_skip(); } Token::SingleQuotedString(ref s) | Token::DoubleQuotedString(ref s) if after_newline => { str.push_str(s.clone().as_str()); self.next_token_no_skip(); after_newline = false; } _ => break, } } } str } /// Parse an unsigned numeric literal pub fn parse_number_value(&mut self) -> Result { let value_wrapper = self.parse_value()?; match &value_wrapper.value { Value::Number(_, _) => Ok(value_wrapper), Value::Placeholder(_) => Ok(value_wrapper), _ => { self.prev_token(); self.expected_ref("literal number", self.peek_token_ref()) } } } /// Parse a numeric literal as an expression. Returns a [`Expr::UnaryOp`] if the number is signed, /// otherwise returns a [`Expr::Value`] pub fn parse_number(&mut self) -> Result { let next_token = self.next_token(); match next_token.token { Token::Plus => Ok(Expr::UnaryOp { op: UnaryOperator::Plus, expr: Box::new(Expr::Value(self.parse_number_value()?)), }), Token::Minus => Ok(Expr::UnaryOp { op: UnaryOperator::Minus, expr: Box::new(Expr::Value(self.parse_number_value()?)), }), _ => { self.prev_token(); Ok(Expr::Value(self.parse_number_value()?)) } } } fn parse_introduced_string_expr(&mut self) -> Result { let next_token = self.next_token(); let span = next_token.span; match next_token.token { Token::SingleQuotedString(ref s) => Ok(Expr::Value( Value::SingleQuotedString(s.to_string()).with_span(span), )), Token::DoubleQuotedString(ref s) => Ok(Expr::Value( Value::DoubleQuotedString(s.to_string()).with_span(span), )), Token::HexStringLiteral(ref s) => Ok(Expr::Value( Value::HexStringLiteral(s.to_string()).with_span(span), )), unexpected => self.expected( "a string value", TokenWithSpan { token: unexpected, span, }, ), } } /// Parse an unsigned literal integer/long pub fn parse_literal_uint(&mut self) -> Result { let next_token = self.next_token(); match next_token.token { Token::Number(s, _) => Self::parse::(s, next_token.span.start), _ => self.expected("literal int", next_token), } } /// Parse the body of a `CREATE FUNCTION` specified as a string. /// e.g. `CREATE FUNCTION ... AS $$ body $$`. fn parse_create_function_body_string(&mut self) -> Result { let parse_string_expr = |parser: &mut Parser| -> Result { let peek_token = parser.peek_token(); let span = peek_token.span; match peek_token.token { Token::DollarQuotedString(s) if dialect_of!(parser is PostgreSqlDialect | GenericDialect) => { parser.next_token(); Ok(Expr::Value(Value::DollarQuotedString(s).with_span(span))) } _ => Ok(Expr::Value( Value::SingleQuotedString(parser.parse_literal_string()?).with_span(span), )), } }; Ok(CreateFunctionBody::AsBeforeOptions { body: parse_string_expr(self)?, link_symbol: if self.consume_token(&Token::Comma) { Some(parse_string_expr(self)?) } else { None }, }) } /// Parse a literal string pub fn parse_literal_string(&mut self) -> Result { let next_token = self.next_token(); match next_token.token { Token::Word(Word { value, keyword: Keyword::NoKeyword, .. }) => Ok(value), Token::SingleQuotedString(s) => Ok(s), Token::DoubleQuotedString(s) => Ok(s), Token::EscapedStringLiteral(s) if dialect_of!(self is PostgreSqlDialect | GenericDialect) => { Ok(s) } Token::UnicodeStringLiteral(s) => Ok(s), _ => self.expected("literal string", next_token), } } /// Parse a boolean string pub(crate) fn parse_boolean_string(&mut self) -> Result { match self.parse_one_of_keywords(&[Keyword::TRUE, Keyword::FALSE]) { Some(Keyword::TRUE) => Ok(true), Some(Keyword::FALSE) => Ok(false), _ => self.expected_ref("TRUE or FALSE", self.peek_token_ref()), } } /// Parse a literal unicode normalization clause pub fn parse_unicode_is_normalized(&mut self, expr: Expr) -> Result { let neg = self.parse_keyword(Keyword::NOT); let normalized_form = self.maybe_parse(|parser| { match parser.parse_one_of_keywords(&[ Keyword::NFC, Keyword::NFD, Keyword::NFKC, Keyword::NFKD, ]) { Some(Keyword::NFC) => Ok(NormalizationForm::NFC), Some(Keyword::NFD) => Ok(NormalizationForm::NFD), Some(Keyword::NFKC) => Ok(NormalizationForm::NFKC), Some(Keyword::NFKD) => Ok(NormalizationForm::NFKD), _ => parser.expected_ref("unicode normalization form", parser.peek_token_ref()), } })?; if self.parse_keyword(Keyword::NORMALIZED) { return Ok(Expr::IsNormalized { expr: Box::new(expr), form: normalized_form, negated: neg, }); } self.expected_ref("unicode normalization form", self.peek_token_ref()) } /// Parse parenthesized enum members, used with `ENUM(...)` type definitions. pub fn parse_enum_values(&mut self) -> Result, ParserError> { self.expect_token(&Token::LParen)?; let values = self.parse_comma_separated(|parser| { let name = parser.parse_literal_string()?; let e = if parser.consume_token(&Token::Eq) { let value = parser.parse_number()?; EnumMember::NamedValue(name, value) } else { EnumMember::Name(name) }; Ok(e) })?; self.expect_token(&Token::RParen)?; Ok(values) } /// Parse a SQL datatype (in the context of a CREATE TABLE statement for example) pub fn parse_data_type(&mut self) -> Result { let (ty, trailing_bracket) = self.parse_data_type_helper()?; if trailing_bracket.0 { return parser_err!( format!("unmatched > after parsing data type {ty}"), self.peek_token_ref() ); } Ok(ty) } fn parse_data_type_helper( &mut self, ) -> Result<(DataType, MatchedTrailingBracket), ParserError> { let dialect = self.dialect; self.advance_token(); let next_token = self.get_current_token(); let next_token_index = self.get_current_index(); let mut trailing_bracket: MatchedTrailingBracket = false.into(); let mut data = match &next_token.token { Token::Word(w) => match w.keyword { Keyword::BOOLEAN => Ok(DataType::Boolean), Keyword::BOOL => Ok(DataType::Bool), Keyword::FLOAT => { let precision = self.parse_exact_number_optional_precision_scale()?; if self.parse_keyword(Keyword::UNSIGNED) { Ok(DataType::FloatUnsigned(precision)) } else { Ok(DataType::Float(precision)) } } Keyword::REAL => { if self.parse_keyword(Keyword::UNSIGNED) { Ok(DataType::RealUnsigned) } else { Ok(DataType::Real) } } Keyword::FLOAT4 => Ok(DataType::Float4), Keyword::FLOAT32 => Ok(DataType::Float32), Keyword::FLOAT64 => Ok(DataType::Float64), Keyword::FLOAT8 => Ok(DataType::Float8), Keyword::DOUBLE => { if self.parse_keyword(Keyword::PRECISION) { if self.parse_keyword(Keyword::UNSIGNED) { Ok(DataType::DoublePrecisionUnsigned) } else { Ok(DataType::DoublePrecision) } } else { let precision = self.parse_exact_number_optional_precision_scale()?; if self.parse_keyword(Keyword::UNSIGNED) { Ok(DataType::DoubleUnsigned(precision)) } else { Ok(DataType::Double(precision)) } } } Keyword::TINYINT => { let optional_precision = self.parse_optional_precision(); if self.parse_keyword(Keyword::UNSIGNED) { Ok(DataType::TinyIntUnsigned(optional_precision?)) } else { if dialect.supports_data_type_signed_suffix() { let _ = self.parse_keyword(Keyword::SIGNED); } Ok(DataType::TinyInt(optional_precision?)) } } Keyword::INT2 => { let optional_precision = self.parse_optional_precision(); if self.parse_keyword(Keyword::UNSIGNED) { Ok(DataType::Int2Unsigned(optional_precision?)) } else { Ok(DataType::Int2(optional_precision?)) } } Keyword::SMALLINT => { let optional_precision = self.parse_optional_precision(); if self.parse_keyword(Keyword::UNSIGNED) { Ok(DataType::SmallIntUnsigned(optional_precision?)) } else { if dialect.supports_data_type_signed_suffix() { let _ = self.parse_keyword(Keyword::SIGNED); } Ok(DataType::SmallInt(optional_precision?)) } } Keyword::MEDIUMINT => { let optional_precision = self.parse_optional_precision(); if self.parse_keyword(Keyword::UNSIGNED) { Ok(DataType::MediumIntUnsigned(optional_precision?)) } else { if dialect.supports_data_type_signed_suffix() { let _ = self.parse_keyword(Keyword::SIGNED); } Ok(DataType::MediumInt(optional_precision?)) } } Keyword::INT => { let optional_precision = self.parse_optional_precision(); if self.parse_keyword(Keyword::UNSIGNED) { Ok(DataType::IntUnsigned(optional_precision?)) } else { if dialect.supports_data_type_signed_suffix() { let _ = self.parse_keyword(Keyword::SIGNED); } Ok(DataType::Int(optional_precision?)) } } Keyword::INT4 => { let optional_precision = self.parse_optional_precision(); if self.parse_keyword(Keyword::UNSIGNED) { Ok(DataType::Int4Unsigned(optional_precision?)) } else { Ok(DataType::Int4(optional_precision?)) } } Keyword::INT8 => { let optional_precision = self.parse_optional_precision(); if self.parse_keyword(Keyword::UNSIGNED) { Ok(DataType::Int8Unsigned(optional_precision?)) } else { Ok(DataType::Int8(optional_precision?)) } } Keyword::INT16 => Ok(DataType::Int16), Keyword::INT32 => Ok(DataType::Int32), Keyword::INT64 => Ok(DataType::Int64), Keyword::INT128 => Ok(DataType::Int128), Keyword::INT256 => Ok(DataType::Int256), Keyword::INTEGER => { let optional_precision = self.parse_optional_precision(); if self.parse_keyword(Keyword::UNSIGNED) { Ok(DataType::IntegerUnsigned(optional_precision?)) } else { if dialect.supports_data_type_signed_suffix() { let _ = self.parse_keyword(Keyword::SIGNED); } Ok(DataType::Integer(optional_precision?)) } } Keyword::BIGINT => { let optional_precision = self.parse_optional_precision(); if self.parse_keyword(Keyword::UNSIGNED) { Ok(DataType::BigIntUnsigned(optional_precision?)) } else { if dialect.supports_data_type_signed_suffix() { let _ = self.parse_keyword(Keyword::SIGNED); } Ok(DataType::BigInt(optional_precision?)) } } Keyword::HUGEINT => Ok(DataType::HugeInt), Keyword::UBIGINT => Ok(DataType::UBigInt), Keyword::UHUGEINT => Ok(DataType::UHugeInt), Keyword::USMALLINT => Ok(DataType::USmallInt), Keyword::UTINYINT => Ok(DataType::UTinyInt), Keyword::UINT8 => Ok(DataType::UInt8), Keyword::UINT16 => Ok(DataType::UInt16), Keyword::UINT32 => Ok(DataType::UInt32), Keyword::UINT64 => Ok(DataType::UInt64), Keyword::UINT128 => Ok(DataType::UInt128), Keyword::UINT256 => Ok(DataType::UInt256), Keyword::VARCHAR => Ok(DataType::Varchar(self.parse_optional_character_length()?)), Keyword::NVARCHAR => { Ok(DataType::Nvarchar(self.parse_optional_character_length()?)) } Keyword::CHARACTER => { if self.parse_keyword(Keyword::VARYING) { Ok(DataType::CharacterVarying( self.parse_optional_character_length()?, )) } else if self.parse_keywords(&[Keyword::LARGE, Keyword::OBJECT]) { Ok(DataType::CharacterLargeObject( self.parse_optional_precision()?, )) } else { Ok(DataType::Character(self.parse_optional_character_length()?)) } } Keyword::CHAR => { if self.parse_keyword(Keyword::VARYING) { Ok(DataType::CharVarying( self.parse_optional_character_length()?, )) } else if self.parse_keywords(&[Keyword::LARGE, Keyword::OBJECT]) { Ok(DataType::CharLargeObject(self.parse_optional_precision()?)) } else { Ok(DataType::Char(self.parse_optional_character_length()?)) } } Keyword::CLOB => Ok(DataType::Clob(self.parse_optional_precision()?)), Keyword::BINARY => Ok(DataType::Binary(self.parse_optional_precision()?)), Keyword::VARBINARY => Ok(DataType::Varbinary(self.parse_optional_binary_length()?)), Keyword::BLOB => Ok(DataType::Blob(self.parse_optional_precision()?)), Keyword::TINYBLOB => Ok(DataType::TinyBlob), Keyword::MEDIUMBLOB => Ok(DataType::MediumBlob), Keyword::LONGBLOB => Ok(DataType::LongBlob), Keyword::LONG if self.dialect.supports_long_type_as_bigint() => { Ok(DataType::BigInt(None)) } Keyword::BYTES => Ok(DataType::Bytes(self.parse_optional_precision()?)), Keyword::BIT => { if self.parse_keyword(Keyword::VARYING) { Ok(DataType::BitVarying(self.parse_optional_precision()?)) } else { Ok(DataType::Bit(self.parse_optional_precision()?)) } } Keyword::VARBIT => Ok(DataType::VarBit(self.parse_optional_precision()?)), Keyword::UUID => Ok(DataType::Uuid), Keyword::DATE => Ok(DataType::Date), Keyword::DATE32 => Ok(DataType::Date32), Keyword::DATETIME => Ok(DataType::Datetime(self.parse_optional_precision()?)), Keyword::DATETIME64 => { self.prev_token(); let (precision, time_zone) = self.parse_datetime_64()?; Ok(DataType::Datetime64(precision, time_zone)) } Keyword::TIMESTAMP => { let precision = self.parse_optional_precision()?; let tz = if self.parse_keyword(Keyword::WITH) { self.expect_keywords(&[Keyword::TIME, Keyword::ZONE])?; TimezoneInfo::WithTimeZone } else if self.parse_keyword(Keyword::WITHOUT) { self.expect_keywords(&[Keyword::TIME, Keyword::ZONE])?; TimezoneInfo::WithoutTimeZone } else { TimezoneInfo::None }; Ok(DataType::Timestamp(precision, tz)) } Keyword::TIMESTAMPTZ => Ok(DataType::Timestamp( self.parse_optional_precision()?, TimezoneInfo::Tz, )), Keyword::TIMESTAMP_NTZ => { Ok(DataType::TimestampNtz(self.parse_optional_precision()?)) } Keyword::TIME => { let precision = self.parse_optional_precision()?; let tz = if self.parse_keyword(Keyword::WITH) { self.expect_keywords(&[Keyword::TIME, Keyword::ZONE])?; TimezoneInfo::WithTimeZone } else if self.parse_keyword(Keyword::WITHOUT) { self.expect_keywords(&[Keyword::TIME, Keyword::ZONE])?; TimezoneInfo::WithoutTimeZone } else { TimezoneInfo::None }; Ok(DataType::Time(precision, tz)) } Keyword::TIMETZ => Ok(DataType::Time( self.parse_optional_precision()?, TimezoneInfo::Tz, )), Keyword::INTERVAL => { if self.dialect.supports_interval_options() { let fields = self.maybe_parse_optional_interval_fields()?; let precision = self.parse_optional_precision()?; Ok(DataType::Interval { fields, precision }) } else { Ok(DataType::Interval { fields: None, precision: None, }) } } Keyword::JSON => Ok(DataType::JSON), Keyword::JSONB => Ok(DataType::JSONB), Keyword::REGCLASS => Ok(DataType::Regclass), Keyword::STRING => Ok(DataType::String(self.parse_optional_precision()?)), Keyword::FIXEDSTRING => { self.expect_token(&Token::LParen)?; let character_length = self.parse_literal_uint()?; self.expect_token(&Token::RParen)?; Ok(DataType::FixedString(character_length)) } Keyword::TEXT => { if let Some(modifiers) = self.parse_optional_type_modifiers()? { Ok(DataType::Custom( ObjectName::from(vec![Ident::new("TEXT")]), modifiers, )) } else { Ok(DataType::Text) } } Keyword::TINYTEXT => Ok(DataType::TinyText), Keyword::MEDIUMTEXT => Ok(DataType::MediumText), Keyword::LONGTEXT => Ok(DataType::LongText), Keyword::BYTEA => Ok(DataType::Bytea), Keyword::NUMERIC => Ok(DataType::Numeric( self.parse_exact_number_optional_precision_scale()?, )), Keyword::DECIMAL => { let precision = self.parse_exact_number_optional_precision_scale()?; if self.parse_keyword(Keyword::UNSIGNED) { Ok(DataType::DecimalUnsigned(precision)) } else { Ok(DataType::Decimal(precision)) } } Keyword::DEC => { let precision = self.parse_exact_number_optional_precision_scale()?; if self.parse_keyword(Keyword::UNSIGNED) { Ok(DataType::DecUnsigned(precision)) } else { Ok(DataType::Dec(precision)) } } Keyword::BIGNUMERIC => Ok(DataType::BigNumeric( self.parse_exact_number_optional_precision_scale()?, )), Keyword::BIGDECIMAL => Ok(DataType::BigDecimal( self.parse_exact_number_optional_precision_scale()?, )), Keyword::ENUM => Ok(DataType::Enum(self.parse_enum_values()?, None)), Keyword::ENUM8 => Ok(DataType::Enum(self.parse_enum_values()?, Some(8))), Keyword::ENUM16 => Ok(DataType::Enum(self.parse_enum_values()?, Some(16))), Keyword::SET => Ok(DataType::Set(self.parse_string_values()?)), Keyword::ARRAY => { if self.dialect.supports_array_typedef_without_element_type() { Ok(DataType::Array(ArrayElemTypeDef::None)) } else if dialect_of!(self is ClickHouseDialect) { Ok(self.parse_sub_type(|internal_type| { DataType::Array(ArrayElemTypeDef::Parenthesis(internal_type)) })?) } else { self.expect_token(&Token::Lt)?; let (inside_type, _trailing_bracket) = self.parse_data_type_helper()?; trailing_bracket = self.expect_closing_angle_bracket(_trailing_bracket)?; Ok(DataType::Array(ArrayElemTypeDef::AngleBracket(Box::new( inside_type, )))) } } Keyword::STRUCT if dialect_is!(dialect is DuckDbDialect) => { self.prev_token(); let field_defs = self.parse_duckdb_struct_type_def()?; Ok(DataType::Struct(field_defs, StructBracketKind::Parentheses)) } Keyword::STRUCT if self.dialect.supports_struct_literal() => { self.prev_token(); let (field_defs, _trailing_bracket) = self.parse_struct_type_def(Self::parse_struct_field_def)?; trailing_bracket = _trailing_bracket; Ok(DataType::Struct( field_defs, StructBracketKind::AngleBrackets, )) } Keyword::UNION if dialect_is!(dialect is DuckDbDialect | GenericDialect) => { self.prev_token(); let fields = self.parse_union_type_def()?; Ok(DataType::Union(fields)) } Keyword::NULLABLE if dialect_is!(dialect is ClickHouseDialect | GenericDialect) => { Ok(self.parse_sub_type(DataType::Nullable)?) } Keyword::LOWCARDINALITY if dialect_is!(dialect is ClickHouseDialect | GenericDialect) => { Ok(self.parse_sub_type(DataType::LowCardinality)?) } Keyword::MAP if self.dialect.supports_map_literal_with_angle_brackets() => { self.expect_token(&Token::Lt)?; let key_data_type = self.parse_data_type()?; self.expect_token(&Token::Comma)?; let (value_data_type, _trailing_bracket) = self.parse_data_type_helper()?; trailing_bracket = self.expect_closing_angle_bracket(_trailing_bracket)?; Ok(DataType::Map( Box::new(key_data_type), Box::new(value_data_type), )) } Keyword::MAP if dialect_is!(dialect is ClickHouseDialect | GenericDialect) => { self.prev_token(); let (key_data_type, value_data_type) = self.parse_click_house_map_def()?; Ok(DataType::Map( Box::new(key_data_type), Box::new(value_data_type), )) } Keyword::NESTED if dialect_is!(dialect is ClickHouseDialect | GenericDialect) => { self.expect_token(&Token::LParen)?; let field_defs = self.parse_comma_separated(Parser::parse_column_def)?; self.expect_token(&Token::RParen)?; Ok(DataType::Nested(field_defs)) } Keyword::TUPLE if dialect_is!(dialect is ClickHouseDialect | GenericDialect) => { self.prev_token(); let field_defs = self.parse_click_house_tuple_def()?; Ok(DataType::Tuple(field_defs)) } Keyword::TRIGGER => Ok(DataType::Trigger), Keyword::ANY if self.peek_keyword(Keyword::TYPE) => { let _ = self.parse_keyword(Keyword::TYPE); Ok(DataType::AnyType) } Keyword::TABLE => { // an LParen after the TABLE keyword indicates that table columns are being defined // whereas no LParen indicates an anonymous table expression will be returned if self.peek_token_ref().token == Token::LParen { let columns = self.parse_returns_table_columns()?; Ok(DataType::Table(Some(columns))) } else { Ok(DataType::Table(None)) } } Keyword::SIGNED => { if self.parse_keyword(Keyword::INTEGER) { Ok(DataType::SignedInteger) } else { Ok(DataType::Signed) } } Keyword::UNSIGNED => { if self.parse_keyword(Keyword::INTEGER) { Ok(DataType::UnsignedInteger) } else { Ok(DataType::Unsigned) } } Keyword::TSVECTOR if dialect_is!(dialect is PostgreSqlDialect | GenericDialect) => { Ok(DataType::TsVector) } Keyword::TSQUERY if dialect_is!(dialect is PostgreSqlDialect | GenericDialect) => { Ok(DataType::TsQuery) } _ => { self.prev_token(); let type_name = self.parse_object_name(false)?; if let Some(modifiers) = self.parse_optional_type_modifiers()? { Ok(DataType::Custom(type_name, modifiers)) } else { Ok(DataType::Custom(type_name, vec![])) } } }, _ => self.expected_at("a data type name", next_token_index), }?; if self.dialect.supports_array_typedef_with_brackets() { while self.consume_token(&Token::LBracket) { // Parse optional array data type size let size = self.maybe_parse(|p| p.parse_literal_uint())?; self.expect_token(&Token::RBracket)?; data = DataType::Array(ArrayElemTypeDef::SquareBracket(Box::new(data), size)) } } Ok((data, trailing_bracket)) } fn parse_returns_table_column(&mut self) -> Result { self.parse_column_def() } fn parse_returns_table_columns(&mut self) -> Result, ParserError> { self.expect_token(&Token::LParen)?; let columns = self.parse_comma_separated(Parser::parse_returns_table_column)?; self.expect_token(&Token::RParen)?; Ok(columns) } /// Parse a parenthesized, comma-separated list of single-quoted strings. pub fn parse_string_values(&mut self) -> Result, ParserError> { self.expect_token(&Token::LParen)?; let mut values = Vec::new(); loop { let next_token = self.next_token(); match next_token.token { Token::SingleQuotedString(value) => values.push(value), _ => self.expected("a string", next_token)?, } let next_token = self.next_token(); match next_token.token { Token::Comma => (), Token::RParen => break, _ => self.expected(", or }", next_token)?, } } Ok(values) } /// Strictly parse `identifier AS identifier` pub fn parse_identifier_with_alias(&mut self) -> Result { let ident = self.parse_identifier()?; self.expect_keyword_is(Keyword::AS)?; let alias = self.parse_identifier()?; Ok(IdentWithAlias { ident, alias }) } /// Parse `identifier [AS] identifier` where the AS keyword is optional fn parse_identifier_with_optional_alias(&mut self) -> Result { let ident = self.parse_identifier()?; let _after_as = self.parse_keyword(Keyword::AS); let alias = self.parse_identifier()?; Ok(IdentWithAlias { ident, alias }) } /// Parse comma-separated list of parenthesized queries for pipe operators fn parse_pipe_operator_queries(&mut self) -> Result, ParserError> { self.parse_comma_separated(|parser| { parser.expect_token(&Token::LParen)?; let query = parser.parse_query()?; parser.expect_token(&Token::RParen)?; Ok(*query) }) } /// Parse set quantifier for pipe operators that require DISTINCT. E.g. INTERSECT and EXCEPT fn parse_distinct_required_set_quantifier( &mut self, operator_name: &str, ) -> Result { let quantifier = self.parse_set_quantifier(&Some(SetOperator::Intersect)); match quantifier { SetQuantifier::Distinct | SetQuantifier::DistinctByName => Ok(quantifier), _ => Err(ParserError::ParserError(format!( "{operator_name} pipe operator requires DISTINCT modifier", ))), } } /// Parse optional identifier alias (with or without AS keyword) fn parse_identifier_optional_alias(&mut self) -> Result, ParserError> { if self.parse_keyword(Keyword::AS) { Ok(Some(self.parse_identifier()?)) } else { // Check if the next token is an identifier (implicit alias) self.maybe_parse(|parser| parser.parse_identifier()) } } /// Optionally parses an alias for a select list item fn maybe_parse_select_item_alias(&mut self) -> Result, ParserError> { fn validator(explicit: bool, kw: &Keyword, parser: &mut Parser) -> bool { parser.dialect.is_select_item_alias(explicit, kw, parser) } self.parse_optional_alias_inner(None, validator) } /// Optionally parses an alias for a table like in `... FROM generate_series(1, 10) AS t (col)`. /// In this case, the alias is allowed to optionally name the columns in the table, in /// addition to the table itself. pub fn maybe_parse_table_alias(&mut self) -> Result, ParserError> { fn validator(explicit: bool, kw: &Keyword, parser: &mut Parser) -> bool { parser.dialect.is_table_factor_alias(explicit, kw, parser) } let explicit = self.peek_keyword(Keyword::AS); match self.parse_optional_alias_inner(None, validator)? { Some(name) => { let columns = self.parse_table_alias_column_defs()?; let at = if self.dialect.supports_partiql() && self.parse_keyword(Keyword::AT) { Some(self.parse_identifier()?) } else { None }; Ok(Some(TableAlias { explicit, name, columns, at, })) } None => Ok(None), } } fn parse_table_index_hints(&mut self) -> Result, ParserError> { let mut hints = vec![]; while let Some(hint_type) = self.parse_one_of_keywords(&[Keyword::USE, Keyword::IGNORE, Keyword::FORCE]) { let hint_type = match hint_type { Keyword::USE => TableIndexHintType::Use, Keyword::IGNORE => TableIndexHintType::Ignore, Keyword::FORCE => TableIndexHintType::Force, _ => { return self.expected_ref( "expected to match USE/IGNORE/FORCE keyword", self.peek_token_ref(), ) } }; let index_type = match self.parse_one_of_keywords(&[Keyword::INDEX, Keyword::KEY]) { Some(Keyword::INDEX) => TableIndexType::Index, Some(Keyword::KEY) => TableIndexType::Key, _ => { return self .expected_ref("expected to match INDEX/KEY keyword", self.peek_token_ref()) } }; let for_clause = if self.parse_keyword(Keyword::FOR) { let clause = if self.parse_keyword(Keyword::JOIN) { TableIndexHintForClause::Join } else if self.parse_keywords(&[Keyword::ORDER, Keyword::BY]) { TableIndexHintForClause::OrderBy } else if self.parse_keywords(&[Keyword::GROUP, Keyword::BY]) { TableIndexHintForClause::GroupBy } else { return self.expected_ref( "expected to match FOR/ORDER BY/GROUP BY table hint in for clause", self.peek_token_ref(), ); }; Some(clause) } else { None }; self.expect_token(&Token::LParen)?; let index_names = if self.peek_token_ref().token != Token::RParen { self.parse_comma_separated(Parser::parse_identifier)? } else { vec![] }; self.expect_token(&Token::RParen)?; hints.push(TableIndexHints { hint_type, index_type, for_clause, index_names, }); } Ok(hints) } /// Wrapper for parse_optional_alias_inner, left for backwards-compatibility /// but new flows should use the context-specific methods such as `maybe_parse_select_item_alias` /// and `maybe_parse_table_alias`. pub fn parse_optional_alias( &mut self, reserved_kwds: &[Keyword], ) -> Result, ParserError> { fn validator(_explicit: bool, _kw: &Keyword, _parser: &mut Parser) -> bool { false } self.parse_optional_alias_inner(Some(reserved_kwds), validator) } /// Parses an optional alias after a SQL element such as a select list item /// or a table name. /// /// This method accepts an optional list of reserved keywords or a function /// to call to validate if a keyword should be parsed as an alias, to allow /// callers to customize the parsing logic based on their context. fn parse_optional_alias_inner( &mut self, reserved_kwds: Option<&[Keyword]>, validator: F, ) -> Result, ParserError> where F: Fn(bool, &Keyword, &mut Parser) -> bool, { let after_as = self.parse_keyword(Keyword::AS); let next_token = self.next_token(); match next_token.token { // Accepts a keyword as an alias if the AS keyword explicitly indicate an alias or if the // caller provided a list of reserved keywords and the keyword is not on that list. Token::Word(w) if reserved_kwds.is_some() && (after_as || reserved_kwds.is_some_and(|x| !x.contains(&w.keyword))) => { Ok(Some(w.into_ident(next_token.span))) } // Accepts a keyword as alias based on the caller's context, such as to what SQL element // this word is a potential alias of using the validator call-back. This allows for // dialect-specific logic. Token::Word(w) if validator(after_as, &w.keyword, self) => { Ok(Some(w.into_ident(next_token.span))) } // For backwards-compatibility, we accept quoted strings as aliases regardless of the context. Token::SingleQuotedString(s) => Ok(Some(Ident::with_quote('\'', s))), Token::DoubleQuotedString(s) => Ok(Some(Ident::with_quote('\"', s))), _ => { if after_as { return self.expected("an identifier after AS", next_token); } self.prev_token(); Ok(None) // no alias found } } } /// Parse an optional `GROUP BY` clause, returning `Some(GroupByExpr)` when present. pub fn parse_optional_group_by(&mut self) -> Result, ParserError> { if self.parse_keywords(&[Keyword::GROUP, Keyword::BY]) { let expressions = if self.parse_keyword(Keyword::ALL) { None } else { Some(self.parse_comma_separated(Parser::parse_group_by_expr)?) }; let mut modifiers = vec![]; if self.dialect.supports_group_by_with_modifier() { loop { if !self.parse_keyword(Keyword::WITH) { break; } let keyword = self.expect_one_of_keywords(&[ Keyword::ROLLUP, Keyword::CUBE, Keyword::TOTALS, ])?; modifiers.push(match keyword { Keyword::ROLLUP => GroupByWithModifier::Rollup, Keyword::CUBE => GroupByWithModifier::Cube, Keyword::TOTALS => GroupByWithModifier::Totals, _ => { return parser_err!( "BUG: expected to match GroupBy modifier keyword", self.peek_token_ref().span.start ) } }); } } if self.parse_keywords(&[Keyword::GROUPING, Keyword::SETS]) { self.expect_token(&Token::LParen)?; let result = self.parse_comma_separated(|p| { if p.peek_token_ref().token == Token::LParen { p.parse_tuple(true, true) } else { Ok(vec![p.parse_expr()?]) } })?; self.expect_token(&Token::RParen)?; modifiers.push(GroupByWithModifier::GroupingSets(Expr::GroupingSets( result, ))); }; let group_by = match expressions { None => GroupByExpr::All(modifiers), Some(exprs) => GroupByExpr::Expressions(exprs, modifiers), }; Ok(Some(group_by)) } else { Ok(None) } } /// Parse an optional `ORDER BY` clause, returning `Some(OrderBy)` when present. pub fn parse_optional_order_by(&mut self) -> Result, ParserError> { if self.parse_keywords(&[Keyword::ORDER, Keyword::BY]) { let order_by = if self.dialect.supports_order_by_all() && self.parse_keyword(Keyword::ALL) { let order_by_options = self.parse_order_by_options()?; OrderBy { kind: OrderByKind::All(order_by_options), interpolate: None, } } else { let exprs = self.parse_comma_separated(Parser::parse_order_by_expr)?; let interpolate = if self.dialect.supports_interpolate() { self.parse_interpolations()? } else { None }; OrderBy { kind: OrderByKind::Expressions(exprs), interpolate, } }; Ok(Some(order_by)) } else { Ok(None) } } fn parse_optional_limit_clause(&mut self) -> Result, ParserError> { let mut offset = if self.parse_keyword(Keyword::OFFSET) { Some(self.parse_offset()?) } else { None }; let (limit, limit_by) = if self.parse_keyword(Keyword::LIMIT) { let expr = self.parse_limit()?; if self.dialect.supports_limit_comma() && offset.is_none() && expr.is_some() // ALL not supported with comma && self.consume_token(&Token::Comma) { let offset = expr.ok_or_else(|| { ParserError::ParserError( "Missing offset for LIMIT , ".to_string(), ) })?; return Ok(Some(LimitClause::OffsetCommaLimit { offset, limit: self.parse_expr()?, })); } let limit_by = if self.dialect.supports_limit_by() && self.parse_keyword(Keyword::BY) { Some(self.parse_comma_separated(Parser::parse_expr)?) } else { None }; (Some(expr), limit_by) } else { (None, None) }; if offset.is_none() && limit.is_some() && self.parse_keyword(Keyword::OFFSET) { offset = Some(self.parse_offset()?); } if offset.is_some() || (limit.is_some() && limit != Some(None)) || limit_by.is_some() { Ok(Some(LimitClause::LimitOffset { limit: limit.unwrap_or_default(), offset, limit_by: limit_by.unwrap_or_default(), })) } else { Ok(None) } } /// Parse a table object for insertion /// e.g. `some_database.some_table` or `FUNCTION some_table_func(...)` pub fn parse_table_object(&mut self) -> Result { if self.dialect.supports_insert_table_function() && self.parse_keyword(Keyword::FUNCTION) { let fn_name = self.parse_object_name(false)?; self.parse_function_call(fn_name) .map(TableObject::TableFunction) } else if self.dialect.supports_insert_table_query() && self.peek_subquery_or_cte_start() { self.parse_parenthesized(|p| p.parse_query()) .map(TableObject::TableQuery) } else { self.parse_object_name(false).map(TableObject::TableName) } } /// Parse a possibly qualified, possibly quoted identifier, e.g. /// `foo` or `myschema."table" /// /// The `in_table_clause` parameter indicates whether the object name is a table in a FROM, JOIN, /// or similar table clause. Currently, this is used only to support unquoted hyphenated identifiers /// in this context on BigQuery. pub fn parse_object_name(&mut self, in_table_clause: bool) -> Result { self.parse_object_name_inner(in_table_clause, false) } /// Parse a possibly qualified, possibly quoted identifier, e.g. /// `foo` or `myschema."table" /// /// The `in_table_clause` parameter indicates whether the object name is a table in a FROM, JOIN, /// or similar table clause. Currently, this is used only to support unquoted hyphenated identifiers /// in this context on BigQuery. /// /// The `allow_wildcards` parameter indicates whether to allow for wildcards in the object name /// e.g. *, *.*, `foo`.*, or "foo"."bar" fn parse_object_name_inner( &mut self, in_table_clause: bool, allow_wildcards: bool, ) -> Result { let mut parts = vec![]; if dialect_of!(self is BigQueryDialect) && in_table_clause { loop { let (ident, end_with_period) = self.parse_unquoted_hyphenated_identifier()?; parts.push(ObjectNamePart::Identifier(ident)); if !self.consume_token(&Token::Period) && !end_with_period { break; } } } else { loop { if allow_wildcards && self.peek_token_ref().token == Token::Mul { let span = self.next_token().span; parts.push(ObjectNamePart::Identifier(Ident { value: Token::Mul.to_string(), quote_style: None, span, })); } else if dialect_of!(self is BigQueryDialect) && in_table_clause { let (ident, end_with_period) = self.parse_unquoted_hyphenated_identifier()?; parts.push(ObjectNamePart::Identifier(ident)); if !self.consume_token(&Token::Period) && !end_with_period { break; } } else if self.dialect.supports_object_name_double_dot_notation() && parts.len() == 1 && matches!(self.peek_token_ref().token, Token::Period) { // Empty string here means default schema parts.push(ObjectNamePart::Identifier(Ident::new(""))); } else { let ident = self.parse_identifier()?; let part = if self .dialect .is_identifier_generating_function_name(&ident, &parts) { self.expect_token(&Token::LParen)?; let args: Vec = self.parse_comma_separated0(Self::parse_function_args, Token::RParen)?; self.expect_token(&Token::RParen)?; ObjectNamePart::Function(ObjectNamePartFunction { name: ident, args }) } else { ObjectNamePart::Identifier(ident) }; parts.push(part); } if !self.consume_token(&Token::Period) { break; } } } // BigQuery accepts any number of quoted identifiers of a table name. // https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#quoted_identifiers if dialect_of!(self is BigQueryDialect) && parts.iter().any(|part| { part.as_ident() .is_some_and(|ident| ident.value.contains('.')) }) { parts = parts .into_iter() .flat_map(|part| match part.as_ident() { Some(ident) => ident .value .split('.') .map(|value| { ObjectNamePart::Identifier(Ident { value: value.into(), quote_style: ident.quote_style, span: ident.span, }) }) .collect::>(), None => vec![part], }) .collect() } Ok(ObjectName(parts)) } /// Parse identifiers pub fn parse_identifiers(&mut self) -> Result, ParserError> { let mut idents = vec![]; loop { let token = self.peek_token_ref(); match &token.token { Token::Word(w) => { idents.push(w.to_ident(token.span)); } Token::EOF | Token::Eq | Token::SemiColon | Token::VerticalBarRightAngleBracket => { break } _ => {} } self.advance_token(); } Ok(idents) } /// Parse identifiers of form ident1[.identN]* /// /// Similar in functionality to [parse_identifiers], with difference /// being this function is much more strict about parsing a valid multipart identifier, not /// allowing extraneous tokens to be parsed, otherwise it fails. /// /// For example: /// /// ```rust /// use sqlparser::ast::Ident; /// use sqlparser::dialect::GenericDialect; /// use sqlparser::parser::Parser; /// /// let dialect = GenericDialect {}; /// let expected = vec![Ident::new("one"), Ident::new("two")]; /// /// // expected usage /// let sql = "one.two"; /// let mut parser = Parser::new(&dialect).try_with_sql(sql).unwrap(); /// let actual = parser.parse_multipart_identifier().unwrap(); /// assert_eq!(&actual, &expected); /// /// // parse_identifiers is more loose on what it allows, parsing successfully /// let sql = "one + two"; /// let mut parser = Parser::new(&dialect).try_with_sql(sql).unwrap(); /// let actual = parser.parse_identifiers().unwrap(); /// assert_eq!(&actual, &expected); /// /// // expected to strictly fail due to + separator /// let sql = "one + two"; /// let mut parser = Parser::new(&dialect).try_with_sql(sql).unwrap(); /// let actual = parser.parse_multipart_identifier().unwrap_err(); /// assert_eq!( /// actual.to_string(), /// "sql parser error: Unexpected token in identifier: +" /// ); /// ``` /// /// [parse_identifiers]: Parser::parse_identifiers pub fn parse_multipart_identifier(&mut self) -> Result, ParserError> { let mut idents = vec![]; // expecting at least one word for identifier let next_token = self.next_token(); match next_token.token { Token::Word(w) => idents.push(w.into_ident(next_token.span)), Token::EOF => { return Err(ParserError::ParserError( "Empty input when parsing identifier".to_string(), ))? } token => { return Err(ParserError::ParserError(format!( "Unexpected token in identifier: {token}" )))? } }; // parse optional next parts if exist loop { match self.next_token().token { // ensure that optional period is succeeded by another identifier Token::Period => { let next_token = self.next_token(); match next_token.token { Token::Word(w) => idents.push(w.into_ident(next_token.span)), Token::EOF => { return Err(ParserError::ParserError( "Trailing period in identifier".to_string(), ))? } token => { return Err(ParserError::ParserError(format!( "Unexpected token following period in identifier: {token}" )))? } } } Token::EOF => break, token => { return Err(ParserError::ParserError(format!( "Unexpected token in identifier: {token}" )))?; } } } Ok(idents) } /// Parse a simple one-word identifier (possibly quoted, possibly a keyword) pub fn parse_identifier(&mut self) -> Result { let next_token = self.next_token(); match next_token.token { Token::Word(w) => Ok(w.into_ident(next_token.span)), Token::SingleQuotedString(s) => Ok(Ident::with_quote('\'', s)), Token::DoubleQuotedString(s) => Ok(Ident::with_quote('\"', s)), _ => self.expected("identifier", next_token), } } /// On BigQuery, hyphens are permitted in unquoted identifiers inside of a FROM or /// TABLE clause. /// /// The first segment must be an ordinary unquoted identifier, e.g. it must not start /// with a digit. Subsequent segments are either must either be valid identifiers or /// integers, e.g. foo-123 is allowed, but foo-123a is not. /// /// [BigQuery-lexical](https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical) /// /// Return a tuple of the identifier and a boolean indicating it ends with a period. fn parse_unquoted_hyphenated_identifier(&mut self) -> Result<(Ident, bool), ParserError> { match self.peek_token().token { Token::Word(w) => { let quote_style_is_none = w.quote_style.is_none(); let mut requires_whitespace = false; let mut ident = w.into_ident(self.next_token().span); if quote_style_is_none { while matches!(self.peek_token_no_skip().token, Token::Minus) { self.next_token(); ident.value.push('-'); let token = self .next_token_no_skip() .cloned() .unwrap_or(TokenWithSpan::wrap(Token::EOF)); requires_whitespace = match token.token { Token::Word(next_word) if next_word.quote_style.is_none() => { ident.value.push_str(&next_word.value); false } Token::Number(s, false) => { // A number token can represent a decimal value ending with a period, e.g., `Number('123.')`. // However, for an [ObjectName], it is part of a hyphenated identifier, e.g., `foo-123.bar`. // // If a number token is followed by a period, it is part of an [ObjectName]. // Return the identifier with `true` if the number token is followed by a period, indicating that // parsing should continue for the next part of the hyphenated identifier. if s.ends_with('.') { let Some(s) = s.split('.').next().filter(|s| { !s.is_empty() && s.chars().all(|c| c.is_ascii_digit()) }) else { return self.expected( "continuation of hyphenated identifier", TokenWithSpan::new(Token::Number(s, false), token.span), ); }; ident.value.push_str(s); return Ok((ident, true)); } else { ident.value.push_str(&s); } // If next token is period, then it is part of an ObjectName and we don't expect whitespace // after the number. !matches!(self.peek_token_ref().token, Token::Period) } _ => { return self .expected("continuation of hyphenated identifier", token); } } } // If the last segment was a number, we must check that it's followed by whitespace, // otherwise foo-123a will be parsed as `foo-123` with the alias `a`. if requires_whitespace { let token = self.next_token(); if !matches!(token.token, Token::EOF | Token::Whitespace(_)) { return self .expected("whitespace following hyphenated identifier", token); } } } Ok((ident, false)) } _ => Ok((self.parse_identifier()?, false)), } } /// Parses a parenthesized, comma-separated list of column definitions within a view. fn parse_view_columns(&mut self) -> Result, ParserError> { if self.consume_token(&Token::LParen) { if self.peek_token_ref().token == Token::RParen { self.next_token(); Ok(vec![]) } else { let cols = self.parse_comma_separated_with_trailing_commas( Parser::parse_view_column, self.dialect.supports_column_definition_trailing_commas(), Self::is_reserved_for_column_alias, )?; self.expect_token(&Token::RParen)?; Ok(cols) } } else { Ok(vec![]) } } /// Parses a column definition within a view. fn parse_view_column(&mut self) -> Result { let name = self.parse_identifier()?; let options = self.parse_view_column_options()?; let data_type = if dialect_of!(self is ClickHouseDialect) { Some(self.parse_data_type()?) } else { None }; Ok(ViewColumnDef { name, data_type, options, }) } fn parse_view_column_options(&mut self) -> Result, ParserError> { let mut options = Vec::new(); loop { let option = self.parse_optional_column_option()?; if let Some(option) = option { options.push(option); } else { break; } } if options.is_empty() { Ok(None) } else if self.dialect.supports_space_separated_column_options() { Ok(Some(ColumnOptions::SpaceSeparated(options))) } else { Ok(Some(ColumnOptions::CommaSeparated(options))) } } /// Parses a parenthesized comma-separated list of unqualified, possibly quoted identifiers. /// For example: `(col1, "col 2", ...)` pub fn parse_parenthesized_column_list( &mut self, optional: IsOptional, allow_empty: bool, ) -> Result, ParserError> { self.parse_parenthesized_column_list_inner(optional, allow_empty, |p| p.parse_identifier()) } /// Parse a parenthesized list of compound identifiers as expressions. pub fn parse_parenthesized_compound_identifier_list( &mut self, optional: IsOptional, allow_empty: bool, ) -> Result, ParserError> { self.parse_parenthesized_column_list_inner(optional, allow_empty, |p| { Ok(Expr::CompoundIdentifier( p.parse_period_separated(|p| p.parse_identifier())?, )) }) } /// Parses a parenthesized comma-separated list of index columns, which can be arbitrary /// expressions with ordering information (and an opclass in some dialects). fn parse_parenthesized_index_column_list(&mut self) -> Result, ParserError> { self.parse_parenthesized_column_list_inner(Mandatory, false, |p| { p.parse_create_index_expr() }) } /// Parses a parenthesized comma-separated list of qualified, possibly quoted identifiers. /// For example: `(db1.sc1.tbl1.col1, db1.sc1.tbl1."col 2", ...)` pub fn parse_parenthesized_qualified_column_list( &mut self, optional: IsOptional, allow_empty: bool, ) -> Result, ParserError> { self.parse_parenthesized_column_list_inner(optional, allow_empty, |p| { p.parse_object_name(true) }) } /// Parses a parenthesized comma-separated list of columns using /// the provided function to parse each element. fn parse_parenthesized_column_list_inner( &mut self, optional: IsOptional, allow_empty: bool, mut f: F, ) -> Result, ParserError> where F: FnMut(&mut Parser) -> Result, { if self.consume_token(&Token::LParen) { if allow_empty && self.peek_token_ref().token == Token::RParen { self.next_token(); Ok(vec![]) } else { let cols = self.parse_comma_separated(|p| f(p))?; self.expect_token(&Token::RParen)?; Ok(cols) } } else if optional == Optional { Ok(vec![]) } else { self.expected_ref("a list of columns in parentheses", self.peek_token_ref()) } } /// Parses a parenthesized comma-separated list of table alias column definitions. fn parse_table_alias_column_defs(&mut self) -> Result, ParserError> { if self.consume_token(&Token::LParen) { let cols = self.parse_comma_separated(|p| { let name = p.parse_identifier()?; let data_type = p.maybe_parse(|p| p.parse_data_type())?; Ok(TableAliasColumnDef { name, data_type }) })?; self.expect_token(&Token::RParen)?; Ok(cols) } else { Ok(vec![]) } } /// Parse an unsigned precision value enclosed in parentheses, e.g. `(10)`. pub fn parse_precision(&mut self) -> Result { self.expect_token(&Token::LParen)?; let n = self.parse_literal_uint()?; self.expect_token(&Token::RParen)?; Ok(n) } /// Parse an optional precision `(n)` and return it as `Some(n)` when present. pub fn parse_optional_precision(&mut self) -> Result, ParserError> { if self.consume_token(&Token::LParen) { let n = self.parse_literal_uint()?; self.expect_token(&Token::RParen)?; Ok(Some(n)) } else { Ok(None) } } fn maybe_parse_optional_interval_fields( &mut self, ) -> Result, ParserError> { match self.parse_one_of_keywords(&[ // Can be followed by `TO` option Keyword::YEAR, Keyword::DAY, Keyword::HOUR, Keyword::MINUTE, // No `TO` option Keyword::MONTH, Keyword::SECOND, ]) { Some(Keyword::YEAR) => { if self.peek_keyword(Keyword::TO) { self.expect_keyword(Keyword::TO)?; self.expect_keyword(Keyword::MONTH)?; Ok(Some(IntervalFields::YearToMonth)) } else { Ok(Some(IntervalFields::Year)) } } Some(Keyword::DAY) => { if self.peek_keyword(Keyword::TO) { self.expect_keyword(Keyword::TO)?; match self.expect_one_of_keywords(&[ Keyword::HOUR, Keyword::MINUTE, Keyword::SECOND, ])? { Keyword::HOUR => Ok(Some(IntervalFields::DayToHour)), Keyword::MINUTE => Ok(Some(IntervalFields::DayToMinute)), Keyword::SECOND => Ok(Some(IntervalFields::DayToSecond)), _ => { self.prev_token(); self.expected_ref("HOUR, MINUTE, or SECOND", self.peek_token_ref()) } } } else { Ok(Some(IntervalFields::Day)) } } Some(Keyword::HOUR) => { if self.peek_keyword(Keyword::TO) { self.expect_keyword(Keyword::TO)?; match self.expect_one_of_keywords(&[Keyword::MINUTE, Keyword::SECOND])? { Keyword::MINUTE => Ok(Some(IntervalFields::HourToMinute)), Keyword::SECOND => Ok(Some(IntervalFields::HourToSecond)), _ => { self.prev_token(); self.expected_ref("MINUTE or SECOND", self.peek_token_ref()) } } } else { Ok(Some(IntervalFields::Hour)) } } Some(Keyword::MINUTE) => { if self.peek_keyword(Keyword::TO) { self.expect_keyword(Keyword::TO)?; self.expect_keyword(Keyword::SECOND)?; Ok(Some(IntervalFields::MinuteToSecond)) } else { Ok(Some(IntervalFields::Minute)) } } Some(Keyword::MONTH) => Ok(Some(IntervalFields::Month)), Some(Keyword::SECOND) => Ok(Some(IntervalFields::Second)), Some(_) => { self.prev_token(); self.expected_ref( "YEAR, MONTH, DAY, HOUR, MINUTE, or SECOND", self.peek_token_ref(), ) } None => Ok(None), } } /// Parse datetime64 [1] /// Syntax /// ```sql /// DateTime64(precision[, timezone]) /// ``` /// /// [1]: https://clickhouse.com/docs/en/sql-reference/data-types/datetime64 pub fn parse_datetime_64(&mut self) -> Result<(u64, Option), ParserError> { self.expect_keyword_is(Keyword::DATETIME64)?; self.expect_token(&Token::LParen)?; let precision = self.parse_literal_uint()?; let time_zone = if self.consume_token(&Token::Comma) { Some(self.parse_literal_string()?) } else { None }; self.expect_token(&Token::RParen)?; Ok((precision, time_zone)) } /// Parse an optional character length specification `(n | MAX [CHARACTERS|OCTETS])`. pub fn parse_optional_character_length( &mut self, ) -> Result, ParserError> { if self.consume_token(&Token::LParen) { let character_length = self.parse_character_length()?; self.expect_token(&Token::RParen)?; Ok(Some(character_length)) } else { Ok(None) } } /// Parse an optional binary length specification like `(n)`. pub fn parse_optional_binary_length(&mut self) -> Result, ParserError> { if self.consume_token(&Token::LParen) { let binary_length = self.parse_binary_length()?; self.expect_token(&Token::RParen)?; Ok(Some(binary_length)) } else { Ok(None) } } /// Parse a character length, handling `MAX` or integer lengths with optional units. pub fn parse_character_length(&mut self) -> Result { if self.parse_keyword(Keyword::MAX) { return Ok(CharacterLength::Max); } let length = self.parse_literal_uint()?; let unit = if self.parse_keyword(Keyword::CHARACTERS) { Some(CharLengthUnits::Characters) } else if self.parse_keyword(Keyword::OCTETS) { Some(CharLengthUnits::Octets) } else { None }; Ok(CharacterLength::IntegerLength { length, unit }) } /// Parse a binary length specification, returning `BinaryLength`. pub fn parse_binary_length(&mut self) -> Result { if self.parse_keyword(Keyword::MAX) { return Ok(BinaryLength::Max); } let length = self.parse_literal_uint()?; Ok(BinaryLength::IntegerLength { length }) } /// Parse an optional `(precision[, scale])` and return `(Option, Option)`. pub fn parse_optional_precision_scale( &mut self, ) -> Result<(Option, Option), ParserError> { if self.consume_token(&Token::LParen) { let n = self.parse_literal_uint()?; let scale = if self.consume_token(&Token::Comma) { Some(self.parse_literal_uint()?) } else { None }; self.expect_token(&Token::RParen)?; Ok((Some(n), scale)) } else { Ok((None, None)) } } /// Parse exact-number precision/scale info like `(precision[, scale])` for decimal types. pub fn parse_exact_number_optional_precision_scale( &mut self, ) -> Result { if self.consume_token(&Token::LParen) { let precision = self.parse_literal_uint()?; let scale = if self.consume_token(&Token::Comma) { Some(self.parse_signed_integer()?) } else { None }; self.expect_token(&Token::RParen)?; match scale { None => Ok(ExactNumberInfo::Precision(precision)), Some(scale) => Ok(ExactNumberInfo::PrecisionAndScale(precision, scale)), } } else { Ok(ExactNumberInfo::None) } } /// Parse an optionally signed integer literal. fn parse_signed_integer(&mut self) -> Result { let is_negative = self.consume_token(&Token::Minus); if !is_negative { let _ = self.consume_token(&Token::Plus); } let current_token = self.peek_token_ref(); match ¤t_token.token { Token::Number(s, _) => { let s = s.clone(); let span_start = current_token.span.start; self.advance_token(); let value = Self::parse::(s, span_start)?; Ok(if is_negative { -value } else { value }) } _ => self.expected_ref("number", current_token), } } /// Parse optional type modifiers appearing in parentheses e.g. `(UNSIGNED, ZEROFILL)`. pub fn parse_optional_type_modifiers(&mut self) -> Result>, ParserError> { if self.consume_token(&Token::LParen) { let mut modifiers = Vec::new(); loop { let next_token = self.next_token(); match next_token.token { Token::Word(w) => modifiers.push(w.to_string()), Token::Number(n, _) => modifiers.push(n), Token::SingleQuotedString(s) => modifiers.push(s), Token::Comma => { continue; } Token::RParen => { break; } _ => self.expected("type modifiers", next_token)?, } } Ok(Some(modifiers)) } else { Ok(None) } } /// Parse a parenthesized sub data type fn parse_sub_type(&mut self, parent_type: F) -> Result where F: FnOnce(Box) -> DataType, { self.expect_token(&Token::LParen)?; let inside_type = self.parse_data_type()?; self.expect_token(&Token::RParen)?; Ok(parent_type(inside_type.into())) } /// Parse a DELETE statement, returning a `Box`ed SetExpr /// /// This is used to reduce the size of the stack frames in debug builds fn parse_delete_setexpr_boxed( &mut self, delete_token: TokenWithSpan, ) -> Result, ParserError> { Ok(Box::new(SetExpr::Delete(self.parse_delete(delete_token)?))) } /// Parse a `DELETE` statement and return `Statement::Delete`. pub fn parse_delete(&mut self, delete_token: TokenWithSpan) -> Result { let optimizer_hints = self.maybe_parse_optimizer_hints()?; let (tables, with_from_keyword) = if !self.parse_keyword(Keyword::FROM) { // `FROM` keyword is optional in BigQuery SQL. // https://cloud.google.com/bigquery/docs/reference/standard-sql/dml-syntax#delete_statement if dialect_of!(self is BigQueryDialect | OracleDialect | GenericDialect) { (vec![], false) } else { let tables = self.parse_comma_separated(|p| p.parse_object_name(false))?; self.expect_keyword_is(Keyword::FROM)?; (tables, true) } } else { (vec![], true) }; let from = self.parse_comma_separated(Parser::parse_table_and_joins)?; let output = self.maybe_parse_output_clause()?; let using = if self.parse_keyword(Keyword::USING) { Some(self.parse_comma_separated(Parser::parse_table_and_joins)?) } else { None }; let selection = if self.parse_keyword(Keyword::WHERE) { Some(self.parse_expr()?) } else { None }; let returning = if self.parse_keyword(Keyword::RETURNING) { Some(self.parse_comma_separated(Parser::parse_select_item)?) } else { None }; let order_by = if self.parse_keywords(&[Keyword::ORDER, Keyword::BY]) { self.parse_comma_separated(Parser::parse_order_by_expr)? } else { vec![] }; let limit = if self.parse_keyword(Keyword::LIMIT) { self.parse_limit()? } else { None }; Ok(Statement::Delete(Delete { delete_token: delete_token.into(), optimizer_hints, tables, from: if with_from_keyword { FromTable::WithFromKeyword(from) } else { FromTable::WithoutKeyword(from) }, using, selection, returning, output, order_by, limit, })) } /// Parse a `KILL` statement, optionally specifying `CONNECTION`, `QUERY`, or `MUTATION`. /// KILL [CONNECTION | QUERY | MUTATION] processlist_id pub fn parse_kill(&mut self) -> Result { let modifier_keyword = self.parse_one_of_keywords(&[Keyword::CONNECTION, Keyword::QUERY, Keyword::MUTATION]); let id = self.parse_literal_uint()?; let modifier = match modifier_keyword { Some(Keyword::CONNECTION) => Some(KillType::Connection), Some(Keyword::QUERY) => Some(KillType::Query), Some(Keyword::MUTATION) => { if dialect_of!(self is ClickHouseDialect | GenericDialect) { Some(KillType::Mutation) } else { self.expected_ref( "Unsupported type for KILL, allowed: CONNECTION | QUERY", self.peek_token_ref(), )? } } _ => None, }; Ok(Statement::Kill { modifier, id }) } /// Parse an `EXPLAIN` statement, handling dialect-specific options and modifiers. pub fn parse_explain( &mut self, describe_alias: DescribeAlias, ) -> Result { let mut analyze = false; let mut verbose = false; let mut query_plan = false; let mut estimate = false; let mut format = None; let mut options = None; // Note: DuckDB is compatible with PostgreSQL syntax for this statement, // although not all features may be implemented. if describe_alias == DescribeAlias::Explain && self.dialect.supports_explain_with_utility_options() && self.peek_token_ref().token == Token::LParen { options = Some(self.parse_utility_options()?) } else if self.parse_keywords(&[Keyword::QUERY, Keyword::PLAN]) { query_plan = true; } else if self.parse_keyword(Keyword::ESTIMATE) { estimate = true; } else { analyze = self.parse_keyword(Keyword::ANALYZE); verbose = self.parse_keyword(Keyword::VERBOSE); if self.parse_keyword(Keyword::FORMAT) { format = Some(self.parse_analyze_format_kind()?); } } match self.maybe_parse(|parser| parser.parse_statement())? { Some(Statement::Explain { .. }) | Some(Statement::ExplainTable { .. }) => Err( ParserError::ParserError("Explain must be root of the plan".to_string()), ), Some(statement) => Ok(Statement::Explain { describe_alias, analyze, verbose, query_plan, estimate, statement: Box::new(statement), format, options, }), _ => { let hive_format = match self.parse_one_of_keywords(&[Keyword::EXTENDED, Keyword::FORMATTED]) { Some(Keyword::EXTENDED) => Some(HiveDescribeFormat::Extended), Some(Keyword::FORMATTED) => Some(HiveDescribeFormat::Formatted), _ => None, }; let has_table_keyword = if self.dialect.describe_requires_table_keyword() { // only allow to use TABLE keyword for DESC|DESCRIBE statement self.parse_keyword(Keyword::TABLE) } else { false }; let table_name = self.parse_object_name(false)?; Ok(Statement::ExplainTable { describe_alias, hive_format, has_table_keyword, table_name, }) } } } /// Parse a query expression, i.e. a `SELECT` statement optionally /// preceded with some `WITH` CTE declarations and optionally followed /// by `ORDER BY`. Unlike some other parse_... methods, this one doesn't /// expect the initial keyword to be already consumed #[cfg_attr(feature = "recursive-protection", recursive::recursive)] pub fn parse_query(&mut self) -> Result, ParserError> { let _guard = self.recursion_counter.try_decrease()?; let with = if self.parse_keyword(Keyword::WITH) { let with_token = self.get_current_token(); Some(With { with_token: with_token.clone().into(), recursive: self.parse_keyword(Keyword::RECURSIVE), cte_tables: self.parse_comma_separated(Parser::parse_cte)?, }) } else { None }; if self.parse_keyword(Keyword::INSERT) { Ok(Query { with, body: self.parse_insert_setexpr_boxed(self.get_current_token().clone())?, order_by: None, limit_clause: None, fetch: None, locks: vec![], for_clause: None, settings: None, format_clause: None, pipe_operators: vec![], } .into()) } else if self.parse_keyword(Keyword::UPDATE) { Ok(Query { with, body: self.parse_update_setexpr_boxed(self.get_current_token().clone())?, order_by: None, limit_clause: None, fetch: None, locks: vec![], for_clause: None, settings: None, format_clause: None, pipe_operators: vec![], } .into()) } else if self.parse_keyword(Keyword::DELETE) { Ok(Query { with, body: self.parse_delete_setexpr_boxed(self.get_current_token().clone())?, limit_clause: None, order_by: None, fetch: None, locks: vec![], for_clause: None, settings: None, format_clause: None, pipe_operators: vec![], } .into()) } else if self.parse_keyword(Keyword::MERGE) { Ok(Query { with, body: self.parse_merge_setexpr_boxed(self.get_current_token().clone())?, limit_clause: None, order_by: None, fetch: None, locks: vec![], for_clause: None, settings: None, format_clause: None, pipe_operators: vec![], } .into()) } else { let body = self.parse_query_body(self.dialect.prec_unknown())?; let order_by = self.parse_optional_order_by()?; let limit_clause = self.parse_optional_limit_clause()?; let settings = self.parse_settings()?; let fetch = if self.parse_keyword(Keyword::FETCH) { Some(self.parse_fetch()?) } else { None }; let mut for_clause = None; let mut locks = Vec::new(); while self.parse_keyword(Keyword::FOR) { if let Some(parsed_for_clause) = self.parse_for_clause()? { for_clause = Some(parsed_for_clause); break; } else { locks.push(self.parse_lock()?); } } let format_clause = if self.dialect.supports_select_format() && self.parse_keyword(Keyword::FORMAT) { if self.parse_keyword(Keyword::NULL) { Some(FormatClause::Null) } else { let ident = self.parse_identifier()?; Some(FormatClause::Identifier(ident)) } } else { None }; let pipe_operators = if self.dialect.supports_pipe_operator() { self.parse_pipe_operators()? } else { Vec::new() }; Ok(Query { with, body, order_by, limit_clause, fetch, locks, for_clause, settings, format_clause, pipe_operators, } .into()) } } fn parse_pipe_operators(&mut self) -> Result, ParserError> { let mut pipe_operators = Vec::new(); while self.consume_token(&Token::VerticalBarRightAngleBracket) { let kw = self.expect_one_of_keywords(&[ Keyword::SELECT, Keyword::EXTEND, Keyword::SET, Keyword::DROP, Keyword::AS, Keyword::WHERE, Keyword::LIMIT, Keyword::AGGREGATE, Keyword::ORDER, Keyword::TABLESAMPLE, Keyword::RENAME, Keyword::UNION, Keyword::INTERSECT, Keyword::EXCEPT, Keyword::CALL, Keyword::PIVOT, Keyword::UNPIVOT, Keyword::JOIN, Keyword::INNER, Keyword::LEFT, Keyword::RIGHT, Keyword::FULL, Keyword::CROSS, ])?; match kw { Keyword::SELECT => { let exprs = self.parse_comma_separated(Parser::parse_select_item)?; pipe_operators.push(PipeOperator::Select { exprs }) } Keyword::EXTEND => { let exprs = self.parse_comma_separated(Parser::parse_select_item)?; pipe_operators.push(PipeOperator::Extend { exprs }) } Keyword::SET => { let assignments = self.parse_comma_separated(Parser::parse_assignment)?; pipe_operators.push(PipeOperator::Set { assignments }) } Keyword::DROP => { let columns = self.parse_identifiers()?; pipe_operators.push(PipeOperator::Drop { columns }) } Keyword::AS => { let alias = self.parse_identifier()?; pipe_operators.push(PipeOperator::As { alias }) } Keyword::WHERE => { let expr = self.parse_expr()?; pipe_operators.push(PipeOperator::Where { expr }) } Keyword::LIMIT => { let expr = self.parse_expr()?; let offset = if self.parse_keyword(Keyword::OFFSET) { Some(self.parse_expr()?) } else { None }; pipe_operators.push(PipeOperator::Limit { expr, offset }) } Keyword::AGGREGATE => { let full_table_exprs = if self.peek_keyword(Keyword::GROUP) { vec![] } else { self.parse_comma_separated(|parser| { parser.parse_expr_with_alias_and_order_by() })? }; let group_by_expr = if self.parse_keywords(&[Keyword::GROUP, Keyword::BY]) { self.parse_comma_separated(|parser| { parser.parse_expr_with_alias_and_order_by() })? } else { vec![] }; pipe_operators.push(PipeOperator::Aggregate { full_table_exprs, group_by_expr, }) } Keyword::ORDER => { self.expect_one_of_keywords(&[Keyword::BY])?; let exprs = self.parse_comma_separated(Parser::parse_order_by_expr)?; pipe_operators.push(PipeOperator::OrderBy { exprs }) } Keyword::TABLESAMPLE => { let sample = self.parse_table_sample(TableSampleModifier::TableSample)?; pipe_operators.push(PipeOperator::TableSample { sample }); } Keyword::RENAME => { let mappings = self.parse_comma_separated(Parser::parse_identifier_with_optional_alias)?; pipe_operators.push(PipeOperator::Rename { mappings }); } Keyword::UNION => { let set_quantifier = self.parse_set_quantifier(&Some(SetOperator::Union)); let queries = self.parse_pipe_operator_queries()?; pipe_operators.push(PipeOperator::Union { set_quantifier, queries, }); } Keyword::INTERSECT => { let set_quantifier = self.parse_distinct_required_set_quantifier("INTERSECT")?; let queries = self.parse_pipe_operator_queries()?; pipe_operators.push(PipeOperator::Intersect { set_quantifier, queries, }); } Keyword::EXCEPT => { let set_quantifier = self.parse_distinct_required_set_quantifier("EXCEPT")?; let queries = self.parse_pipe_operator_queries()?; pipe_operators.push(PipeOperator::Except { set_quantifier, queries, }); } Keyword::CALL => { let function_name = self.parse_object_name(false)?; let function_expr = self.parse_function(function_name)?; if let Expr::Function(function) = function_expr { let alias = self.parse_identifier_optional_alias()?; pipe_operators.push(PipeOperator::Call { function, alias }); } else { return Err(ParserError::ParserError( "Expected function call after CALL".to_string(), )); } } Keyword::PIVOT => { self.expect_token(&Token::LParen)?; let aggregate_functions = self.parse_comma_separated(Self::parse_pivot_aggregate_function)?; self.expect_keyword_is(Keyword::FOR)?; let value_column = self.parse_period_separated(|p| p.parse_identifier())?; self.expect_keyword_is(Keyword::IN)?; self.expect_token(&Token::LParen)?; let value_source = if self.parse_keyword(Keyword::ANY) { let order_by = if self.parse_keywords(&[Keyword::ORDER, Keyword::BY]) { self.parse_comma_separated(Parser::parse_order_by_expr)? } else { vec![] }; PivotValueSource::Any(order_by) } else if self.peek_sub_query() { PivotValueSource::Subquery(self.parse_query()?) } else { PivotValueSource::List( self.parse_comma_separated(Self::parse_expr_with_alias)?, ) }; self.expect_token(&Token::RParen)?; self.expect_token(&Token::RParen)?; let alias = self.parse_identifier_optional_alias()?; pipe_operators.push(PipeOperator::Pivot { aggregate_functions, value_column, value_source, alias, }); } Keyword::UNPIVOT => { self.expect_token(&Token::LParen)?; let value_column = self.parse_identifier()?; self.expect_keyword(Keyword::FOR)?; let name_column = self.parse_identifier()?; self.expect_keyword(Keyword::IN)?; self.expect_token(&Token::LParen)?; let unpivot_columns = self.parse_comma_separated(Parser::parse_identifier)?; self.expect_token(&Token::RParen)?; self.expect_token(&Token::RParen)?; let alias = self.parse_identifier_optional_alias()?; pipe_operators.push(PipeOperator::Unpivot { value_column, name_column, unpivot_columns, alias, }); } Keyword::JOIN | Keyword::INNER | Keyword::LEFT | Keyword::RIGHT | Keyword::FULL | Keyword::CROSS => { self.prev_token(); let mut joins = self.parse_joins()?; if joins.len() != 1 { return Err(ParserError::ParserError( "Join pipe operator must have a single join".to_string(), )); } let join = joins.swap_remove(0); pipe_operators.push(PipeOperator::Join(join)) } unhandled => { return Err(ParserError::ParserError(format!( "`expect_one_of_keywords` further up allowed unhandled keyword: {unhandled:?}" ))) } } } Ok(pipe_operators) } fn parse_settings(&mut self) -> Result>, ParserError> { let settings = if self.dialect.supports_settings() && self.parse_keyword(Keyword::SETTINGS) { let key_values = self.parse_comma_separated(|p| { let key = p.parse_identifier()?; p.expect_token(&Token::Eq)?; let value = p.parse_expr()?; Ok(Setting { key, value }) })?; Some(key_values) } else { None }; Ok(settings) } /// Parse a mssql `FOR [XML | JSON | BROWSE]` clause pub fn parse_for_clause(&mut self) -> Result, ParserError> { if self.parse_keyword(Keyword::XML) { Ok(Some(self.parse_for_xml()?)) } else if self.parse_keyword(Keyword::JSON) { Ok(Some(self.parse_for_json()?)) } else if self.parse_keyword(Keyword::BROWSE) { Ok(Some(ForClause::Browse)) } else { Ok(None) } } /// Parse a mssql `FOR XML` clause pub fn parse_for_xml(&mut self) -> Result { let for_xml = if self.parse_keyword(Keyword::RAW) { let mut element_name = None; if self.peek_token_ref().token == Token::LParen { self.expect_token(&Token::LParen)?; element_name = Some(self.parse_literal_string()?); self.expect_token(&Token::RParen)?; } ForXml::Raw(element_name) } else if self.parse_keyword(Keyword::AUTO) { ForXml::Auto } else if self.parse_keyword(Keyword::EXPLICIT) { ForXml::Explicit } else if self.parse_keyword(Keyword::PATH) { let mut element_name = None; if self.peek_token_ref().token == Token::LParen { self.expect_token(&Token::LParen)?; element_name = Some(self.parse_literal_string()?); self.expect_token(&Token::RParen)?; } ForXml::Path(element_name) } else { return Err(ParserError::ParserError( "Expected FOR XML [RAW | AUTO | EXPLICIT | PATH ]".to_string(), )); }; let mut elements = false; let mut binary_base64 = false; let mut root = None; let mut r#type = false; while self.peek_token_ref().token == Token::Comma { self.next_token(); if self.parse_keyword(Keyword::ELEMENTS) { elements = true; } else if self.parse_keyword(Keyword::BINARY) { self.expect_keyword_is(Keyword::BASE64)?; binary_base64 = true; } else if self.parse_keyword(Keyword::ROOT) { self.expect_token(&Token::LParen)?; root = Some(self.parse_literal_string()?); self.expect_token(&Token::RParen)?; } else if self.parse_keyword(Keyword::TYPE) { r#type = true; } } Ok(ForClause::Xml { for_xml, elements, binary_base64, root, r#type, }) } /// Parse a mssql `FOR JSON` clause pub fn parse_for_json(&mut self) -> Result { let for_json = if self.parse_keyword(Keyword::AUTO) { ForJson::Auto } else if self.parse_keyword(Keyword::PATH) { ForJson::Path } else { return Err(ParserError::ParserError( "Expected FOR JSON [AUTO | PATH ]".to_string(), )); }; let mut root = None; let mut include_null_values = false; let mut without_array_wrapper = false; while self.peek_token_ref().token == Token::Comma { self.next_token(); if self.parse_keyword(Keyword::ROOT) { self.expect_token(&Token::LParen)?; root = Some(self.parse_literal_string()?); self.expect_token(&Token::RParen)?; } else if self.parse_keyword(Keyword::INCLUDE_NULL_VALUES) { include_null_values = true; } else if self.parse_keyword(Keyword::WITHOUT_ARRAY_WRAPPER) { without_array_wrapper = true; } } Ok(ForClause::Json { for_json, root, include_null_values, without_array_wrapper, }) } /// Parse a CTE (`alias [( col1, col2, ... )] [AS] (subquery)`) pub fn parse_cte(&mut self) -> Result { let name = self.parse_identifier()?; let as_optional = self.dialect.supports_cte_without_as(); // If AS is optional, first try to parse `name (query)` directly if as_optional && !self.peek_keyword(Keyword::AS) { if let Some((query, closing_paren_token)) = self.maybe_parse(|p| { p.expect_token(&Token::LParen)?; let query = p.parse_query()?; let closing_paren_token = p.expect_token(&Token::RParen)?; Ok((query, closing_paren_token)) })? { let mut cte = Cte { alias: TableAlias { explicit: false, name, columns: vec![], at: None, }, query, from: None, materialized: None, closing_paren_token: closing_paren_token.into(), }; if self.parse_keyword(Keyword::FROM) { cte.from = Some(self.parse_identifier()?); } return Ok(cte); } } // Determine column definitions and consume AS let columns = if self.parse_keyword(Keyword::AS) { vec![] } else { let columns = self.parse_table_alias_column_defs()?; if as_optional { let _ = self.parse_keyword(Keyword::AS); } else { self.expect_keyword_is(Keyword::AS)?; } columns }; let mut is_materialized = None; if dialect_of!(self is PostgreSqlDialect) { if self.parse_keyword(Keyword::MATERIALIZED) { is_materialized = Some(CteAsMaterialized::Materialized); } else if self.parse_keywords(&[Keyword::NOT, Keyword::MATERIALIZED]) { is_materialized = Some(CteAsMaterialized::NotMaterialized); } } self.expect_token(&Token::LParen)?; let query = self.parse_query()?; let closing_paren_token = self.expect_token(&Token::RParen)?; let mut cte = Cte { alias: TableAlias { explicit: false, name, columns, at: None, }, query, from: None, materialized: is_materialized, closing_paren_token: closing_paren_token.into(), }; if self.dialect.supports_from_first_insert() && self.parse_keyword(Keyword::FROM) { cte.from = Some(self.parse_identifier()?); } Ok(cte) } /// Parse a "query body", which is an expression with roughly the /// following grammar: /// ```sql /// query_body ::= restricted_select | '(' subquery ')' | set_operation /// restricted_select ::= 'SELECT' [expr_list] [ from ] [ where ] [ groupby_having ] /// subquery ::= query_body [ order_by_limit ] /// set_operation ::= query_body { 'UNION' | 'EXCEPT' | 'INTERSECT' } [ 'ALL' ] query_body /// ``` pub fn parse_query_body(&mut self, precedence: u8) -> Result, ParserError> { // We parse the expression using a Pratt parser, as in `parse_expr()`. // Start by parsing a restricted SELECT or a `(subquery)`: let expr = if self.peek_keyword(Keyword::SELECT) || (self.peek_keyword(Keyword::FROM) && self.dialect.supports_from_first_select()) { SetExpr::Select(self.parse_select().map(Box::new)?) } else if self.consume_token(&Token::LParen) { // CTEs are not allowed here, but the parser currently accepts them let subquery = self.parse_query()?; self.expect_token(&Token::RParen)?; SetExpr::Query(subquery) } else if self.parse_keyword(Keyword::VALUES) { let is_mysql = dialect_of!(self is MySqlDialect); SetExpr::Values(self.parse_values(is_mysql, false)?) } else if self.parse_keyword(Keyword::VALUE) { let is_mysql = dialect_of!(self is MySqlDialect); SetExpr::Values(self.parse_values(is_mysql, true)?) } else if self.parse_keyword(Keyword::TABLE) { SetExpr::Table(Box::new(self.parse_as_table()?)) } else { return self.expected_ref( "SELECT, VALUES, or a subquery in the query body", self.peek_token_ref(), ); }; self.parse_remaining_set_exprs(expr, precedence) } /// Parse any extra set expressions that may be present in a query body /// /// (this is its own function to reduce required stack size in debug builds) fn parse_remaining_set_exprs( &mut self, mut expr: SetExpr, precedence: u8, ) -> Result, ParserError> { loop { // The query can be optionally followed by a set operator: let op = self.parse_set_operator(&self.peek_token().token); let next_precedence = match op { // UNION and EXCEPT have the same binding power and evaluate left-to-right Some(SetOperator::Union) | Some(SetOperator::Except) | Some(SetOperator::Minus) => { 10 } // INTERSECT has higher precedence than UNION/EXCEPT Some(SetOperator::Intersect) => 20, // Unexpected token or EOF => stop parsing the query body None => break, }; if precedence >= next_precedence { break; } self.next_token(); // skip past the set operator let set_quantifier = self.parse_set_quantifier(&op); expr = SetExpr::SetOperation { left: Box::new(expr), op: op.unwrap(), set_quantifier, right: self.parse_query_body(next_precedence)?, }; } Ok(expr.into()) } /// Parse a set operator token into its `SetOperator` variant. pub fn parse_set_operator(&mut self, token: &Token) -> Option { match token { Token::Word(w) if w.keyword == Keyword::UNION => Some(SetOperator::Union), Token::Word(w) if w.keyword == Keyword::EXCEPT => Some(SetOperator::Except), Token::Word(w) if w.keyword == Keyword::INTERSECT => Some(SetOperator::Intersect), Token::Word(w) if w.keyword == Keyword::MINUS => Some(SetOperator::Minus), _ => None, } } /// Parse a set quantifier (e.g., `ALL`, `DISTINCT BY NAME`) for the given set operator. pub fn parse_set_quantifier(&mut self, op: &Option) -> SetQuantifier { match op { Some( SetOperator::Except | SetOperator::Intersect | SetOperator::Union | SetOperator::Minus, ) => { if self.parse_keywords(&[Keyword::DISTINCT, Keyword::BY, Keyword::NAME]) { SetQuantifier::DistinctByName } else if self.parse_keywords(&[Keyword::BY, Keyword::NAME]) { SetQuantifier::ByName } else if self.parse_keyword(Keyword::ALL) { if self.parse_keywords(&[Keyword::BY, Keyword::NAME]) { SetQuantifier::AllByName } else { SetQuantifier::All } } else if self.parse_keyword(Keyword::DISTINCT) { SetQuantifier::Distinct } else { SetQuantifier::None } } _ => SetQuantifier::None, } } /// Parse a restricted `SELECT` statement (no CTEs / `UNION` / `ORDER BY`) pub fn parse_select(&mut self) -> Result { let mut from_first = None; if self.dialect.supports_from_first_select() && self.peek_keyword(Keyword::FROM) { let from_token = self.expect_keyword(Keyword::FROM)?; let from = self.parse_table_with_joins()?; if !self.peek_keyword(Keyword::SELECT) { return Ok(Select { select_token: AttachedToken(from_token), optimizer_hints: vec![], distinct: None, select_modifiers: None, top: None, top_before_distinct: false, projection: vec![], exclude: None, into: None, from, lateral_views: vec![], prewhere: None, selection: None, group_by: GroupByExpr::Expressions(vec![], vec![]), cluster_by: vec![], distribute_by: vec![], sort_by: vec![], having: None, named_window: vec![], window_before_qualify: false, qualify: None, value_table_mode: None, connect_by: vec![], flavor: SelectFlavor::FromFirstNoSelect, }); } from_first = Some(from); } let select_token = self.expect_keyword(Keyword::SELECT)?; let optimizer_hints = self.maybe_parse_optimizer_hints()?; let value_table_mode = self.parse_value_table_mode()?; let (select_modifiers, distinct_select_modifier) = if self.dialect.supports_select_modifiers() { self.parse_select_modifiers()? } else { (None, None) }; let mut top_before_distinct = false; let mut top = None; if self.dialect.supports_top_before_distinct() && self.parse_keyword(Keyword::TOP) { top = Some(self.parse_top()?); top_before_distinct = true; } let distinct = if distinct_select_modifier.is_some() { distinct_select_modifier } else { self.parse_all_or_distinct()? }; if !self.dialect.supports_top_before_distinct() && self.parse_keyword(Keyword::TOP) { top = Some(self.parse_top()?); } let projection = if self.dialect.supports_empty_projections() && self.peek_keyword(Keyword::FROM) { vec![] } else { self.parse_projection()? }; let exclude = if self.dialect.supports_select_exclude() { self.parse_optional_select_item_exclude()? } else { None }; let into = if self.parse_keyword(Keyword::INTO) { Some(self.parse_select_into()?) } else { None }; // Note that for keywords to be properly handled here, they need to be // added to `RESERVED_FOR_COLUMN_ALIAS` / `RESERVED_FOR_TABLE_ALIAS`, // otherwise they may be parsed as an alias as part of the `projection` // or `from`. let (from, from_first) = if let Some(from) = from_first.take() { (from, true) } else if self.parse_keyword(Keyword::FROM) { (self.parse_table_with_joins()?, false) } else { (vec![], false) }; let mut lateral_views = vec![]; loop { if self.parse_keywords(&[Keyword::LATERAL, Keyword::VIEW]) { let outer = self.parse_keyword(Keyword::OUTER); let lateral_view = self.parse_expr()?; let lateral_view_name = self.parse_object_name(false)?; let lateral_col_alias = self .parse_comma_separated(|parser| { parser.parse_optional_alias(&[ Keyword::WHERE, Keyword::GROUP, Keyword::CLUSTER, Keyword::HAVING, Keyword::LATERAL, ]) // This couldn't possibly be a bad idea })? .into_iter() .flatten() .collect(); lateral_views.push(LateralView { lateral_view, lateral_view_name, lateral_col_alias, outer, }); } else { break; } } let prewhere = if self.dialect.supports_prewhere() && self.parse_keyword(Keyword::PREWHERE) { Some(self.parse_expr()?) } else { None }; let selection = if self.parse_keyword(Keyword::WHERE) { Some(self.parse_expr()?) } else { None }; let connect_by = self.maybe_parse_connect_by()?; let group_by = self .parse_optional_group_by()? .unwrap_or_else(|| GroupByExpr::Expressions(vec![], vec![])); let cluster_by = if self.parse_keywords(&[Keyword::CLUSTER, Keyword::BY]) { self.parse_comma_separated(Parser::parse_expr)? } else { vec![] }; let distribute_by = if self.parse_keywords(&[Keyword::DISTRIBUTE, Keyword::BY]) { self.parse_comma_separated(Parser::parse_expr)? } else { vec![] }; let sort_by = if self.parse_keywords(&[Keyword::SORT, Keyword::BY]) { self.parse_comma_separated(Parser::parse_order_by_expr)? } else { vec![] }; let having = if self.parse_keyword(Keyword::HAVING) { Some(self.parse_expr()?) } else { None }; // Accept QUALIFY and WINDOW in any order and flag accordingly. let (named_windows, qualify, window_before_qualify) = if self.parse_keyword(Keyword::WINDOW) { let named_windows = self.parse_comma_separated(Parser::parse_named_window)?; if self.parse_keyword(Keyword::QUALIFY) { (named_windows, Some(self.parse_expr()?), true) } else { (named_windows, None, true) } } else if self.parse_keyword(Keyword::QUALIFY) { let qualify = Some(self.parse_expr()?); if self.parse_keyword(Keyword::WINDOW) { ( self.parse_comma_separated(Parser::parse_named_window)?, qualify, false, ) } else { (Default::default(), qualify, false) } } else { Default::default() }; Ok(Select { select_token: AttachedToken(select_token), optimizer_hints, distinct, select_modifiers, top, top_before_distinct, projection, exclude, into, from, lateral_views, prewhere, selection, group_by, cluster_by, distribute_by, sort_by, having, named_window: named_windows, window_before_qualify, qualify, value_table_mode, connect_by, flavor: if from_first { SelectFlavor::FromFirst } else { SelectFlavor::Standard }, }) } /// Parses optimizer hints at the current token position. /// /// Collects all `/*prefix+...*/` and `--prefix+...` patterns. /// The `prefix` is any run of ASCII alphanumeric characters between the /// comment marker and `+` (e.g. `""` for `/*+...*/`, `"abc"` for `/*abc+...*/`). /// /// [MySQL](https://dev.mysql.com/doc/refman/8.4/en/optimizer-hints.html#optimizer-hints-overview) /// [Oracle](https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/Comments.html#GUID-D316D545-89E2-4D54-977F-FC97815CD62E) fn maybe_parse_optimizer_hints(&mut self) -> Result, ParserError> { let supports_hints = self.dialect.supports_comment_optimizer_hint(); if !supports_hints { return Ok(vec![]); } let mut hints = vec![]; loop { let t = self.peek_nth_token_no_skip_ref(0); let Token::Whitespace(ws) = &t.token else { break; }; match ws { Whitespace::SingleLineComment { comment, prefix } => { if let Some((hint_prefix, text)) = Self::extract_hint_prefix_and_text(comment) { hints.push(OptimizerHint { prefix: hint_prefix, text, style: OptimizerHintStyle::SingleLine { prefix: prefix.clone(), }, }); } self.next_token_no_skip(); } Whitespace::MultiLineComment(comment) => { if let Some((hint_prefix, text)) = Self::extract_hint_prefix_and_text(comment) { hints.push(OptimizerHint { prefix: hint_prefix, text, style: OptimizerHintStyle::MultiLine, }); } self.next_token_no_skip(); } Whitespace::Space | Whitespace::Tab | Whitespace::Newline => { self.next_token_no_skip(); } } } Ok(hints) } /// Checks if a comment's content starts with `[ASCII-alphanumeric]*+` /// and returns `(prefix, text_after_plus)` if so. fn extract_hint_prefix_and_text(comment: &str) -> Option<(String, String)> { let (before_plus, text) = comment.split_once('+')?; if before_plus.chars().all(|c| c.is_ascii_alphanumeric()) { Some((before_plus.to_string(), text.to_string())) } else { None } } /// Parses MySQL SELECT modifiers and DISTINCT/ALL in any order. /// /// Manual testing shows odifiers can appear in any order, and modifiers other than DISTINCT/ALL /// can be repeated. /// /// fn parse_select_modifiers( &mut self, ) -> Result<(Option, Option), ParserError> { let mut modifiers = SelectModifiers::default(); let mut distinct = None; let keywords = &[ Keyword::ALL, Keyword::DISTINCT, Keyword::DISTINCTROW, Keyword::HIGH_PRIORITY, Keyword::STRAIGHT_JOIN, Keyword::SQL_SMALL_RESULT, Keyword::SQL_BIG_RESULT, Keyword::SQL_BUFFER_RESULT, Keyword::SQL_NO_CACHE, Keyword::SQL_CALC_FOUND_ROWS, ]; while let Some(keyword) = self.parse_one_of_keywords(keywords) { match keyword { Keyword::ALL | Keyword::DISTINCT if distinct.is_none() => { self.prev_token(); distinct = self.parse_all_or_distinct()?; } // DISTINCTROW is a MySQL-specific legacy (but not deprecated) alias for DISTINCT Keyword::DISTINCTROW if distinct.is_none() => { distinct = Some(Distinct::Distinct); } Keyword::HIGH_PRIORITY => modifiers.high_priority = true, Keyword::STRAIGHT_JOIN => modifiers.straight_join = true, Keyword::SQL_SMALL_RESULT => modifiers.sql_small_result = true, Keyword::SQL_BIG_RESULT => modifiers.sql_big_result = true, Keyword::SQL_BUFFER_RESULT => modifiers.sql_buffer_result = true, Keyword::SQL_NO_CACHE => modifiers.sql_no_cache = true, Keyword::SQL_CALC_FOUND_ROWS => modifiers.sql_calc_found_rows = true, _ => { self.prev_token(); return self.expected_ref( "HIGH_PRIORITY, STRAIGHT_JOIN, or other MySQL select modifier", self.peek_token_ref(), ); } } } // Avoid polluting the AST with `Some(SelectModifiers::default())` empty value unless there // actually were some modifiers set. let select_modifiers = if modifiers.is_any_set() { Some(modifiers) } else { None }; Ok((select_modifiers, distinct)) } fn parse_value_table_mode(&mut self) -> Result, ParserError> { if !dialect_of!(self is BigQueryDialect) { return Ok(None); } let mode = if self.parse_keywords(&[Keyword::DISTINCT, Keyword::AS, Keyword::VALUE]) { Some(ValueTableMode::DistinctAsValue) } else if self.parse_keywords(&[Keyword::DISTINCT, Keyword::AS, Keyword::STRUCT]) { Some(ValueTableMode::DistinctAsStruct) } else if self.parse_keywords(&[Keyword::AS, Keyword::VALUE]) || self.parse_keywords(&[Keyword::ALL, Keyword::AS, Keyword::VALUE]) { Some(ValueTableMode::AsValue) } else if self.parse_keywords(&[Keyword::AS, Keyword::STRUCT]) || self.parse_keywords(&[Keyword::ALL, Keyword::AS, Keyword::STRUCT]) { Some(ValueTableMode::AsStruct) } else if self.parse_keyword(Keyword::AS) { self.expected_ref("VALUE or STRUCT", self.peek_token_ref())? } else { None }; Ok(mode) } /// Invoke `f` after first setting the parser's `ParserState` to `state`. /// /// Upon return, restores the parser's state to what it started at. fn with_state(&mut self, state: ParserState, mut f: F) -> Result where F: FnMut(&mut Parser) -> Result, { let current_state = self.state; self.state = state; let res = f(self); self.state = current_state; res } /// Parse a `CONNECT BY` clause (Oracle-style hierarchical query support). pub fn maybe_parse_connect_by(&mut self) -> Result, ParserError> { let mut clauses = Vec::with_capacity(2); loop { if let Some(idx) = self.parse_keywords_indexed(&[Keyword::START, Keyword::WITH]) { clauses.push(ConnectByKind::StartWith { start_token: self.token_at(idx).clone().into(), condition: self.parse_expr()?.into(), }); } else if let Some(idx) = self.parse_keywords_indexed(&[Keyword::CONNECT, Keyword::BY]) { clauses.push(ConnectByKind::ConnectBy { connect_token: self.token_at(idx).clone().into(), nocycle: self.parse_keyword(Keyword::NOCYCLE), relationships: self.with_state(ParserState::ConnectBy, |parser| { parser.parse_comma_separated(Parser::parse_expr) })?, }); } else { break; } } Ok(clauses) } /// Parse `CREATE TABLE x AS TABLE y` pub fn parse_as_table(&mut self) -> Result { let token1 = self.next_token(); let token2 = self.next_token(); let token3 = self.next_token(); let table_name; let schema_name; if token2 == Token::Period { match token1.token { Token::Word(w) => { schema_name = w.value; } _ => { return self.expected("Schema name", token1); } } match token3.token { Token::Word(w) => { table_name = w.value; } _ => { return self.expected("Table name", token3); } } Ok(Table { table_name: Some(table_name), schema_name: Some(schema_name), }) } else { match token1.token { Token::Word(w) => { table_name = w.value; } _ => { return self.expected("Table name", token1); } } Ok(Table { table_name: Some(table_name), schema_name: None, }) } } /// Parse a `SET ROLE` statement. Expects SET to be consumed already. fn parse_set_role( &mut self, modifier: Option, ) -> Result { self.expect_keyword_is(Keyword::ROLE)?; let role_name = if self.parse_keyword(Keyword::NONE) { None } else { Some(self.parse_identifier()?) }; Ok(Statement::Set(Set::SetRole { context_modifier: modifier, role_name, })) } fn parse_set_values( &mut self, parenthesized_assignment: bool, ) -> Result, ParserError> { let mut values = vec![]; if parenthesized_assignment { self.expect_token(&Token::LParen)?; } loop { let value = if let Some(expr) = self.try_parse_expr_sub_query()? { expr } else if let Ok(expr) = self.parse_expr() { expr } else { self.expected_ref("variable value", self.peek_token_ref())? }; values.push(value); if self.consume_token(&Token::Comma) { continue; } if parenthesized_assignment { self.expect_token(&Token::RParen)?; } return Ok(values); } } fn parse_context_modifier(&mut self) -> Option { let modifier = self.parse_one_of_keywords(&[Keyword::SESSION, Keyword::LOCAL, Keyword::GLOBAL])?; Self::keyword_to_modifier(modifier) } /// Parse a single SET statement assignment `var = expr`. fn parse_set_assignment(&mut self) -> Result { let scope = self.parse_context_modifier(); let name = if self.dialect.supports_parenthesized_set_variables() && self.consume_token(&Token::LParen) { // Parenthesized assignments are handled in the `parse_set` function after // trying to parse list of assignments using this function. // If a dialect supports both, and we find a LParen, we early exit from this function. self.expected_ref("Unparenthesized assignment", self.peek_token_ref())? } else { self.parse_object_name(false)? }; if !(self.consume_token(&Token::Eq) || self.parse_keyword(Keyword::TO)) { return self.expected_ref("assignment operator", self.peek_token_ref()); } let value = self.parse_expr()?; Ok(SetAssignment { scope, name, value }) } fn parse_set(&mut self) -> Result { let hivevar = self.parse_keyword(Keyword::HIVEVAR); // Modifier is either HIVEVAR: or a ContextModifier (LOCAL, SESSION, etc), not both let scope = if !hivevar { self.parse_context_modifier() } else { None }; if hivevar { self.expect_token(&Token::Colon)?; } if let Some(set_role_stmt) = self.maybe_parse(|parser| parser.parse_set_role(scope))? { return Ok(set_role_stmt); } // Handle special cases first if self.parse_keywords(&[Keyword::TIME, Keyword::ZONE]) || self.parse_keyword(Keyword::TIMEZONE) { if self.consume_token(&Token::Eq) || self.parse_keyword(Keyword::TO) { return Ok(Set::SingleAssignment { scope, hivevar, variable: ObjectName::from(vec!["TIMEZONE".into()]), values: self.parse_set_values(false)?, } .into()); } else { // A shorthand alias for SET TIME ZONE that doesn't require // the assignment operator. It's originally PostgreSQL specific, // but we allow it for all the dialects return Ok(Set::SetTimeZone { local: scope == Some(ContextModifier::Local), value: self.parse_expr()?, } .into()); } } else if self.dialect.supports_set_names() && self.parse_keyword(Keyword::NAMES) { if self.parse_keyword(Keyword::DEFAULT) { return Ok(Set::SetNamesDefault {}.into()); } let charset_name = self.parse_identifier()?; let collation_name = if self.parse_one_of_keywords(&[Keyword::COLLATE]).is_some() { Some(self.parse_literal_string()?) } else { None }; return Ok(Set::SetNames { charset_name, collation_name, } .into()); } else if self.parse_keyword(Keyword::CHARACTERISTICS) { self.expect_keywords(&[Keyword::AS, Keyword::TRANSACTION])?; return Ok(Set::SetTransaction { modes: self.parse_transaction_modes()?, snapshot: None, session: true, } .into()); } else if self.parse_keyword(Keyword::TRANSACTION) { if self.parse_keyword(Keyword::SNAPSHOT) { let snapshot_id = self.parse_value()?; return Ok(Set::SetTransaction { modes: vec![], snapshot: Some(snapshot_id), session: false, } .into()); } return Ok(Set::SetTransaction { modes: self.parse_transaction_modes()?, snapshot: None, session: false, } .into()); } else if self.parse_keyword(Keyword::AUTHORIZATION) { let scope = match scope { Some(s) => s, None => { return self.expected_at( "SESSION, LOCAL, or other scope modifier before AUTHORIZATION", self.get_current_index(), ) } }; let auth_value = if self.parse_keyword(Keyword::DEFAULT) { SetSessionAuthorizationParamKind::Default } else { let value = self.parse_identifier()?; SetSessionAuthorizationParamKind::User(value) }; return Ok(Set::SetSessionAuthorization(SetSessionAuthorizationParam { scope, kind: auth_value, }) .into()); } if self.dialect.supports_comma_separated_set_assignments() { if scope.is_some() { self.prev_token(); } if let Some(assignments) = self .maybe_parse(|parser| parser.parse_comma_separated(Parser::parse_set_assignment))? { return if assignments.len() > 1 { Ok(Set::MultipleAssignments { assignments }.into()) } else { let SetAssignment { scope, name, value } = assignments.into_iter().next().ok_or_else(|| { ParserError::ParserError("Expected at least one assignment".to_string()) })?; Ok(Set::SingleAssignment { scope, hivevar, variable: name, values: vec![value], } .into()) }; } } let variables = if self.dialect.supports_parenthesized_set_variables() && self.consume_token(&Token::LParen) { let vars = OneOrManyWithParens::Many( self.parse_comma_separated(|parser: &mut Parser<'a>| parser.parse_identifier())? .into_iter() .map(|ident| ObjectName::from(vec![ident])) .collect(), ); self.expect_token(&Token::RParen)?; vars } else { OneOrManyWithParens::One(self.parse_object_name(false)?) }; if self.consume_token(&Token::Eq) || self.parse_keyword(Keyword::TO) { let stmt = match variables { OneOrManyWithParens::One(var) => Set::SingleAssignment { scope, hivevar, variable: var, values: self.parse_set_values(false)?, }, OneOrManyWithParens::Many(vars) => Set::ParenthesizedAssignments { variables: vars, values: self.parse_set_values(true)?, }, }; return Ok(stmt.into()); } if self.dialect.supports_set_stmt_without_operator() { self.prev_token(); return self.parse_set_session_params(); }; self.expected_ref("equals sign or TO", self.peek_token_ref()) } /// Parse session parameter assignments after `SET` when no `=` or `TO` is present. pub fn parse_set_session_params(&mut self) -> Result { if self.parse_keyword(Keyword::STATISTICS) { let topic = match self.parse_one_of_keywords(&[ Keyword::IO, Keyword::PROFILE, Keyword::TIME, Keyword::XML, ]) { Some(Keyword::IO) => SessionParamStatsTopic::IO, Some(Keyword::PROFILE) => SessionParamStatsTopic::Profile, Some(Keyword::TIME) => SessionParamStatsTopic::Time, Some(Keyword::XML) => SessionParamStatsTopic::Xml, _ => return self.expected_ref("IO, PROFILE, TIME or XML", self.peek_token_ref()), }; let value = self.parse_session_param_value()?; Ok( Set::SetSessionParam(SetSessionParamKind::Statistics(SetSessionParamStatistics { topic, value, })) .into(), ) } else if self.parse_keyword(Keyword::IDENTITY_INSERT) { let obj = self.parse_object_name(false)?; let value = self.parse_session_param_value()?; Ok(Set::SetSessionParam(SetSessionParamKind::IdentityInsert( SetSessionParamIdentityInsert { obj, value }, )) .into()) } else if self.parse_keyword(Keyword::OFFSETS) { let keywords = self.parse_comma_separated(|parser| { let next_token = parser.next_token(); match &next_token.token { Token::Word(w) => Ok(w.to_string()), _ => parser.expected("SQL keyword", next_token), } })?; let value = self.parse_session_param_value()?; Ok( Set::SetSessionParam(SetSessionParamKind::Offsets(SetSessionParamOffsets { keywords, value, })) .into(), ) } else { let names = self.parse_comma_separated(|parser| { let next_token = parser.next_token(); match next_token.token { Token::Word(w) => Ok(w.to_string()), _ => parser.expected("Session param name", next_token), } })?; let value = self.parse_expr()?.to_string(); Ok( Set::SetSessionParam(SetSessionParamKind::Generic(SetSessionParamGeneric { names, value, })) .into(), ) } } fn parse_session_param_value(&mut self) -> Result { if self.parse_keyword(Keyword::ON) { Ok(SessionParamValue::On) } else if self.parse_keyword(Keyword::OFF) { Ok(SessionParamValue::Off) } else { self.expected_ref("ON or OFF", self.peek_token_ref()) } } /// Parse a `SHOW` statement and dispatch to specific SHOW handlers. pub fn parse_show(&mut self) -> Result { let terse = self.parse_keyword(Keyword::TERSE); let extended = self.parse_keyword(Keyword::EXTENDED); let full = self.parse_keyword(Keyword::FULL); let session = self.parse_keyword(Keyword::SESSION); let global = self.parse_keyword(Keyword::GLOBAL); let external = self.parse_keyword(Keyword::EXTERNAL); if self .parse_one_of_keywords(&[Keyword::COLUMNS, Keyword::FIELDS]) .is_some() { Ok(self.parse_show_columns(extended, full)?) } else if self.parse_keyword(Keyword::TABLES) { Ok(self.parse_show_tables(terse, extended, full, external)?) } else if self.parse_keywords(&[Keyword::MATERIALIZED, Keyword::VIEWS]) { Ok(self.parse_show_views(terse, true)?) } else if self.parse_keyword(Keyword::VIEWS) { Ok(self.parse_show_views(terse, false)?) } else if self.parse_keyword(Keyword::FUNCTIONS) { Ok(self.parse_show_functions()?) } else if self.parse_keyword(Keyword::PROCESSLIST) { Ok(Statement::ShowProcessList { full }) } else if extended || full { Err(ParserError::ParserError( "EXTENDED/FULL are not supported with this type of SHOW query".to_string(), )) } else if self.parse_one_of_keywords(&[Keyword::CREATE]).is_some() { Ok(self.parse_show_create()?) } else if self.parse_keyword(Keyword::COLLATION) { Ok(self.parse_show_collation()?) } else if self.parse_keyword(Keyword::VARIABLES) && dialect_of!(self is MySqlDialect | GenericDialect) { Ok(Statement::ShowVariables { filter: self.parse_show_statement_filter()?, session, global, }) } else if self.parse_keyword(Keyword::STATUS) && dialect_of!(self is MySqlDialect | GenericDialect) { Ok(Statement::ShowStatus { filter: self.parse_show_statement_filter()?, session, global, }) } else if self.parse_keyword(Keyword::CATALOGS) { self.parse_show_catalogs(terse) } else if self.parse_keyword(Keyword::DATABASES) { self.parse_show_databases(terse) } else if self.parse_keyword(Keyword::SCHEMAS) { self.parse_show_schemas(terse) } else if self.parse_keywords(&[Keyword::CHARACTER, Keyword::SET]) { self.parse_show_charset(false) } else if self.parse_keyword(Keyword::CHARSET) { self.parse_show_charset(true) } else { Ok(Statement::ShowVariable { variable: self.parse_identifiers()?, }) } } fn parse_show_charset(&mut self, is_shorthand: bool) -> Result { // parse one of keywords Ok(Statement::ShowCharset(ShowCharset { is_shorthand, filter: self.parse_show_statement_filter()?, })) } fn parse_show_catalogs(&mut self, terse: bool) -> Result { let history = self.parse_keyword(Keyword::HISTORY); let show_options = self.parse_show_stmt_options()?; Ok(Statement::ShowCatalogs { terse, history, show_options, }) } fn parse_show_databases(&mut self, terse: bool) -> Result { let history = self.parse_keyword(Keyword::HISTORY); let show_options = self.parse_show_stmt_options()?; Ok(Statement::ShowDatabases { terse, history, show_options, }) } fn parse_show_schemas(&mut self, terse: bool) -> Result { let history = self.parse_keyword(Keyword::HISTORY); let show_options = self.parse_show_stmt_options()?; Ok(Statement::ShowSchemas { terse, history, show_options, }) } /// Parse `SHOW CREATE ` returning the corresponding `ShowCreate` statement. pub fn parse_show_create(&mut self) -> Result { let obj_type = match self.expect_one_of_keywords(&[ Keyword::TABLE, Keyword::TRIGGER, Keyword::FUNCTION, Keyword::PROCEDURE, Keyword::EVENT, Keyword::VIEW, ])? { Keyword::TABLE => Ok(ShowCreateObject::Table), Keyword::TRIGGER => Ok(ShowCreateObject::Trigger), Keyword::FUNCTION => Ok(ShowCreateObject::Function), Keyword::PROCEDURE => Ok(ShowCreateObject::Procedure), Keyword::EVENT => Ok(ShowCreateObject::Event), Keyword::VIEW => Ok(ShowCreateObject::View), keyword => Err(ParserError::ParserError(format!( "Unable to map keyword to ShowCreateObject: {keyword:?}" ))), }?; let obj_name = self.parse_object_name(false)?; Ok(Statement::ShowCreate { obj_type, obj_name }) } /// Parse `SHOW COLUMNS`/`SHOW FIELDS` and return a `ShowColumns` statement. pub fn parse_show_columns( &mut self, extended: bool, full: bool, ) -> Result { let show_options = self.parse_show_stmt_options()?; Ok(Statement::ShowColumns { extended, full, show_options, }) } fn parse_show_tables( &mut self, terse: bool, extended: bool, full: bool, external: bool, ) -> Result { let history = !external && self.parse_keyword(Keyword::HISTORY); let show_options = self.parse_show_stmt_options()?; Ok(Statement::ShowTables { terse, history, extended, full, external, show_options, }) } fn parse_show_views( &mut self, terse: bool, materialized: bool, ) -> Result { let show_options = self.parse_show_stmt_options()?; Ok(Statement::ShowViews { materialized, terse, show_options, }) } /// Parse `SHOW FUNCTIONS` and optional filter. pub fn parse_show_functions(&mut self) -> Result { let filter = self.parse_show_statement_filter()?; Ok(Statement::ShowFunctions { filter }) } /// Parse `SHOW COLLATION` and optional filter. pub fn parse_show_collation(&mut self) -> Result { let filter = self.parse_show_statement_filter()?; Ok(Statement::ShowCollation { filter }) } /// Parse an optional filter used by `SHOW` statements (LIKE, ILIKE, WHERE, or literal). pub fn parse_show_statement_filter( &mut self, ) -> Result, ParserError> { if self.parse_keyword(Keyword::LIKE) { Ok(Some(ShowStatementFilter::Like( self.parse_literal_string()?, ))) } else if self.parse_keyword(Keyword::ILIKE) { Ok(Some(ShowStatementFilter::ILike( self.parse_literal_string()?, ))) } else if self.parse_keyword(Keyword::WHERE) { Ok(Some(ShowStatementFilter::Where(self.parse_expr()?))) } else { self.maybe_parse(|parser| -> Result { parser.parse_literal_string() })? .map_or(Ok(None), |filter| { Ok(Some(ShowStatementFilter::NoKeyword(filter))) }) } } /// Parse a `USE` statement (database/catalog/schema/warehouse/role selection). pub fn parse_use(&mut self) -> Result { // Determine which keywords are recognized by the current dialect let parsed_keyword = if dialect_of!(self is HiveDialect) { // HiveDialect accepts USE DEFAULT; statement without any db specified if self.parse_keyword(Keyword::DEFAULT) { return Ok(Statement::Use(Use::Default)); } None // HiveDialect doesn't expect any other specific keyword after `USE` } else if dialect_of!(self is DatabricksDialect) { self.parse_one_of_keywords(&[Keyword::CATALOG, Keyword::DATABASE, Keyword::SCHEMA]) } else if dialect_of!(self is SnowflakeDialect) { self.parse_one_of_keywords(&[ Keyword::DATABASE, Keyword::SCHEMA, Keyword::WAREHOUSE, Keyword::ROLE, Keyword::SECONDARY, ]) } else { None // No specific keywords for other dialects, including GenericDialect }; let result = if matches!(parsed_keyword, Some(Keyword::SECONDARY)) { self.parse_secondary_roles()? } else { let obj_name = self.parse_object_name(false)?; match parsed_keyword { Some(Keyword::CATALOG) => Use::Catalog(obj_name), Some(Keyword::DATABASE) => Use::Database(obj_name), Some(Keyword::SCHEMA) => Use::Schema(obj_name), Some(Keyword::WAREHOUSE) => Use::Warehouse(obj_name), Some(Keyword::ROLE) => Use::Role(obj_name), _ => Use::Object(obj_name), } }; Ok(Statement::Use(result)) } fn parse_secondary_roles(&mut self) -> Result { self.expect_one_of_keywords(&[Keyword::ROLES, Keyword::ROLE])?; if self.parse_keyword(Keyword::NONE) { Ok(Use::SecondaryRoles(SecondaryRoles::None)) } else if self.parse_keyword(Keyword::ALL) { Ok(Use::SecondaryRoles(SecondaryRoles::All)) } else { let roles = self.parse_comma_separated(|parser| parser.parse_identifier())?; Ok(Use::SecondaryRoles(SecondaryRoles::List(roles))) } } /// Parse a table factor followed by any join clauses, returning `TableWithJoins`. pub fn parse_table_and_joins(&mut self) -> Result { let relation = self.parse_table_factor()?; // Note that for keywords to be properly handled here, they need to be // added to `RESERVED_FOR_TABLE_ALIAS`, otherwise they may be parsed as // a table alias. let joins = self.parse_joins()?; Ok(TableWithJoins { relation, joins }) } fn parse_joins(&mut self) -> Result, ParserError> { let mut joins = vec![]; loop { let global = self.parse_keyword(Keyword::GLOBAL); let join = if self.parse_keyword(Keyword::CROSS) { let join_operator = if self.parse_keyword(Keyword::JOIN) { JoinOperator::CrossJoin(JoinConstraint::None) } else if self.parse_keyword(Keyword::APPLY) { // MSSQL extension, similar to CROSS JOIN LATERAL JoinOperator::CrossApply } else { return self.expected_ref("JOIN or APPLY after CROSS", self.peek_token_ref()); }; let relation = self.parse_table_factor()?; let join_operator = if matches!(join_operator, JoinOperator::CrossJoin(_)) && self.dialect.supports_cross_join_constraint() { let constraint = self.parse_join_constraint(false)?; JoinOperator::CrossJoin(constraint) } else { join_operator }; Join { relation, global, join_operator, } } else if self.parse_keyword(Keyword::OUTER) { // MSSQL extension, similar to LEFT JOIN LATERAL .. ON 1=1 self.expect_keyword_is(Keyword::APPLY)?; Join { relation: self.parse_table_factor()?, global, join_operator: JoinOperator::OuterApply, } } else if self.parse_keyword(Keyword::ASOF) { self.expect_keyword_is(Keyword::JOIN)?; let relation = self.parse_table_factor()?; self.expect_keyword_is(Keyword::MATCH_CONDITION)?; let match_condition = self.parse_parenthesized(Self::parse_expr)?; Join { relation, global, join_operator: JoinOperator::AsOf { match_condition, constraint: self.parse_join_constraint(false)?, }, } } else if self.dialect.supports_array_join_syntax() && self.parse_keywords(&[Keyword::INNER, Keyword::ARRAY, Keyword::JOIN]) { // ClickHouse: INNER ARRAY JOIN Join { relation: self.parse_table_factor()?, global, join_operator: JoinOperator::InnerArrayJoin, } } else if self.dialect.supports_array_join_syntax() && self.parse_keywords(&[Keyword::LEFT, Keyword::ARRAY, Keyword::JOIN]) { // ClickHouse: LEFT ARRAY JOIN Join { relation: self.parse_table_factor()?, global, join_operator: JoinOperator::LeftArrayJoin, } } else if self.dialect.supports_array_join_syntax() && self.parse_keywords(&[Keyword::ARRAY, Keyword::JOIN]) { // ClickHouse: ARRAY JOIN Join { relation: self.parse_table_factor()?, global, join_operator: JoinOperator::ArrayJoin, } } else { let natural = self.parse_keyword(Keyword::NATURAL); let peek_keyword = if let Token::Word(w) = &self.peek_token_ref().token { w.keyword } else { Keyword::NoKeyword }; let join_operator_type = match peek_keyword { Keyword::INNER | Keyword::JOIN => { let inner = self.parse_keyword(Keyword::INNER); // [ INNER ] self.expect_keyword_is(Keyword::JOIN)?; if inner { JoinOperator::Inner } else { JoinOperator::Join } } kw @ Keyword::LEFT | kw @ Keyword::RIGHT => { let _ = self.next_token(); // consume LEFT/RIGHT let is_left = kw == Keyword::LEFT; let join_type = self.parse_one_of_keywords(&[ Keyword::OUTER, Keyword::SEMI, Keyword::ANTI, Keyword::JOIN, ]); match join_type { Some(Keyword::OUTER) => { self.expect_keyword_is(Keyword::JOIN)?; if is_left { JoinOperator::LeftOuter } else { JoinOperator::RightOuter } } Some(Keyword::SEMI) => { self.expect_keyword_is(Keyword::JOIN)?; if is_left { JoinOperator::LeftSemi } else { JoinOperator::RightSemi } } Some(Keyword::ANTI) => { self.expect_keyword_is(Keyword::JOIN)?; if is_left { JoinOperator::LeftAnti } else { JoinOperator::RightAnti } } Some(Keyword::JOIN) => { if is_left { JoinOperator::Left } else { JoinOperator::Right } } _ => { return Err(ParserError::ParserError(format!( "expected OUTER, SEMI, ANTI or JOIN after {kw:?}" ))) } } } Keyword::ANTI => { let _ = self.next_token(); // consume ANTI self.expect_keyword_is(Keyword::JOIN)?; JoinOperator::Anti } Keyword::SEMI => { let _ = self.next_token(); // consume SEMI self.expect_keyword_is(Keyword::JOIN)?; JoinOperator::Semi } Keyword::FULL => { let _ = self.next_token(); // consume FULL let _ = self.parse_keyword(Keyword::OUTER); // [ OUTER ] self.expect_keyword_is(Keyword::JOIN)?; JoinOperator::FullOuter } Keyword::OUTER => { return self.expected_ref("LEFT, RIGHT, or FULL", self.peek_token_ref()); } Keyword::STRAIGHT_JOIN => { let _ = self.next_token(); // consume STRAIGHT_JOIN JoinOperator::StraightJoin } _ if natural => { return self .expected_ref("a join type after NATURAL", self.peek_token_ref()); } _ => break, }; let mut relation = self.parse_table_factor()?; if !self .dialect .supports_left_associative_joins_without_parens() && self.peek_parens_less_nested_join() { let joins = self.parse_joins()?; relation = TableFactor::NestedJoin { table_with_joins: Box::new(TableWithJoins { relation, joins }), alias: None, }; } let join_constraint = self.parse_join_constraint(natural)?; Join { relation, global, join_operator: join_operator_type(join_constraint), } }; joins.push(join); } Ok(joins) } fn peek_parens_less_nested_join(&self) -> bool { matches!( self.peek_token_ref().token, Token::Word(Word { keyword: Keyword::JOIN | Keyword::INNER | Keyword::LEFT | Keyword::RIGHT | Keyword::FULL, .. }) ) } /// A table name or a parenthesized subquery, followed by optional `[AS] alias` #[cfg_attr(feature = "recursive-protection", recursive::recursive)] pub fn parse_table_factor(&mut self) -> Result { let _guard = self.recursion_counter.try_decrease()?; if self.parse_keyword(Keyword::LATERAL) { // LATERAL must always be followed by a subquery or table function. if self.consume_token(&Token::LParen) { self.parse_derived_table_factor(Lateral) } else { let name = self.parse_object_name(false)?; self.expect_token(&Token::LParen)?; let args = self.parse_optional_args()?; let with_ordinality = self.parse_keywords(&[Keyword::WITH, Keyword::ORDINALITY]); let alias = self.maybe_parse_table_alias()?; Ok(TableFactor::Function { lateral: true, name, args, with_ordinality, alias, }) } } else if self.parse_keyword(Keyword::TABLE) { // parse table function (SELECT * FROM TABLE () [ AS ]) self.expect_token(&Token::LParen)?; let expr = self.parse_expr()?; self.expect_token(&Token::RParen)?; let alias = self.maybe_parse_table_alias()?; Ok(TableFactor::TableFunction { expr, alias }) } else if self.consume_token(&Token::LParen) { // A left paren introduces either a derived table (i.e., a subquery) // or a nested join. It's nearly impossible to determine ahead of // time which it is... so we just try to parse both. // // Here's an example that demonstrates the complexity: // /-------------------------------------------------------\ // | /-----------------------------------\ | // SELECT * FROM ( ( ( (SELECT 1) UNION (SELECT 2) ) AS t1 NATURAL JOIN t2 ) ) // ^ ^ ^ ^ // | | | | // | | | | // | | | (4) belongs to a SetExpr::Query inside the subquery // | | (3) starts a derived table (subquery) // | (2) starts a nested join // (1) an additional set of parens around a nested join // // If the recently consumed '(' starts a derived table, the call to // `parse_derived_table_factor` below will return success after parsing the // subquery, followed by the closing ')', and the alias of the derived table. // In the example above this is case (3). if let Some(mut table) = self.maybe_parse(|parser| parser.parse_derived_table_factor(NotLateral))? { while let Some(kw) = self.parse_one_of_keywords(&[Keyword::PIVOT, Keyword::UNPIVOT]) { table = match kw { Keyword::PIVOT => self.parse_pivot_table_factor(table)?, Keyword::UNPIVOT => self.parse_unpivot_table_factor(table)?, unexpected_keyword => return Err(ParserError::ParserError( format!("Internal parser error: unexpected keyword `{unexpected_keyword}` in pivot/unpivot"), )), } } return Ok(table); } // A parsing error from `parse_derived_table_factor` indicates that the '(' we've // recently consumed does not start a derived table (cases 1, 2, or 4). // `maybe_parse` will ignore such an error and rewind to be after the opening '('. // Inside the parentheses we expect to find an (A) table factor // followed by some joins or (B) another level of nesting. let mut table_and_joins = self.parse_table_and_joins()?; #[allow(clippy::if_same_then_else)] if !table_and_joins.joins.is_empty() { self.expect_token(&Token::RParen)?; let alias = self.maybe_parse_table_alias()?; Ok(TableFactor::NestedJoin { table_with_joins: Box::new(table_and_joins), alias, }) // (A) } else if let TableFactor::NestedJoin { table_with_joins: _, alias: _, } = &table_and_joins.relation { // (B): `table_and_joins` (what we found inside the parentheses) // is a nested join `(foo JOIN bar)`, not followed by other joins. self.expect_token(&Token::RParen)?; let alias = self.maybe_parse_table_alias()?; Ok(TableFactor::NestedJoin { table_with_joins: Box::new(table_and_joins), alias, }) } else if self.dialect.supports_parens_around_table_factor() { // Dialect-specific behavior: Snowflake diverges from the // standard and from most of the other implementations by // allowing extra parentheses not only around a join (B), but // around lone table names (e.g. `FROM (mytable [AS alias])`) // and around derived tables (e.g. `FROM ((SELECT ...) // [AS alias])`) as well. self.expect_token(&Token::RParen)?; if let Some(outer_alias) = self.maybe_parse_table_alias()? { // Snowflake also allows specifying an alias *after* parens // e.g. `FROM (mytable) AS alias` match &mut table_and_joins.relation { TableFactor::Derived { alias, .. } | TableFactor::Table { alias, .. } | TableFactor::Function { alias, .. } | TableFactor::UNNEST { alias, .. } | TableFactor::JsonTable { alias, .. } | TableFactor::XmlTable { alias, .. } | TableFactor::OpenJsonTable { alias, .. } | TableFactor::TableFunction { alias, .. } | TableFactor::Pivot { alias, .. } | TableFactor::Unpivot { alias, .. } | TableFactor::MatchRecognize { alias, .. } | TableFactor::SemanticView { alias, .. } | TableFactor::NestedJoin { alias, .. } => { // but not `FROM (mytable AS alias1) AS alias2`. if let Some(inner_alias) = alias { return Err(ParserError::ParserError(format!( "duplicate alias {inner_alias}" ))); } // Act as if the alias was specified normally next // to the table name: `(mytable) AS alias` -> // `(mytable AS alias)` alias.replace(outer_alias); } }; } // Do not store the extra set of parens in the AST Ok(table_and_joins.relation) } else { // The SQL spec prohibits derived tables and bare tables from // appearing alone in parentheses (e.g. `FROM (mytable)`) self.expected_ref("joined table", self.peek_token_ref()) } } else if self.dialect.supports_values_as_table_factor() && matches!( self.peek_tokens(), [ Token::Word(Word { keyword: Keyword::VALUES, .. }), Token::LParen ] ) { self.expect_keyword_is(Keyword::VALUES)?; // Snowflake and Databricks allow syntax like below: // SELECT * FROM VALUES (1, 'a'), (2, 'b') AS t (col1, col2) // where there are no parentheses around the VALUES clause. let values = SetExpr::Values(self.parse_values(false, false)?); let alias = self.maybe_parse_table_alias()?; Ok(TableFactor::Derived { lateral: false, subquery: Box::new(Query { with: None, body: Box::new(values), order_by: None, limit_clause: None, fetch: None, locks: vec![], for_clause: None, settings: None, format_clause: None, pipe_operators: vec![], }), alias, sample: None, }) } else if dialect_of!(self is BigQueryDialect | PostgreSqlDialect | GenericDialect) && self.parse_keyword(Keyword::UNNEST) { self.expect_token(&Token::LParen)?; let array_exprs = self.parse_comma_separated(Parser::parse_expr)?; self.expect_token(&Token::RParen)?; let with_ordinality = self.parse_keywords(&[Keyword::WITH, Keyword::ORDINALITY]); let alias = match self.maybe_parse_table_alias() { Ok(Some(alias)) => Some(alias), Ok(None) => None, Err(e) => return Err(e), }; let with_offset = match self.expect_keywords(&[Keyword::WITH, Keyword::OFFSET]) { Ok(()) => true, Err(_) => false, }; let with_offset_alias = if with_offset { match self.parse_optional_alias(keywords::RESERVED_FOR_COLUMN_ALIAS) { Ok(Some(alias)) => Some(alias), Ok(None) => None, Err(e) => return Err(e), } } else { None }; Ok(TableFactor::UNNEST { alias, array_exprs, with_offset, with_offset_alias, with_ordinality, }) } else if self.parse_keyword_with_tokens(Keyword::JSON_TABLE, &[Token::LParen]) { let json_expr = self.parse_expr()?; self.expect_token(&Token::Comma)?; let json_path = self.parse_value()?; self.expect_keyword_is(Keyword::COLUMNS)?; self.expect_token(&Token::LParen)?; let columns = self.parse_comma_separated(Parser::parse_json_table_column_def)?; self.expect_token(&Token::RParen)?; self.expect_token(&Token::RParen)?; let alias = self.maybe_parse_table_alias()?; Ok(TableFactor::JsonTable { json_expr, json_path, columns, alias, }) } else if self.parse_keyword_with_tokens(Keyword::OPENJSON, &[Token::LParen]) { self.prev_token(); self.parse_open_json_table_factor() } else if self.parse_keyword_with_tokens(Keyword::XMLTABLE, &[Token::LParen]) { self.prev_token(); self.parse_xml_table_factor() } else if self.dialect.supports_semantic_view_table_factor() && self.peek_keyword_with_tokens(Keyword::SEMANTIC_VIEW, &[Token::LParen]) { self.parse_semantic_view_table_factor() } else if self.peek_token_ref().token == Token::AtSign { // Stage reference: @mystage or @namespace.stage (e.g. Snowflake) self.parse_snowflake_stage_table_factor() } else { let name = self.parse_object_name(true)?; let json_path = match &self.peek_token_ref().token { Token::LBracket if self.dialect.supports_partiql() => Some(self.parse_json_path()?), _ => None, }; let partitions: Vec = if dialect_of!(self is MySqlDialect | GenericDialect) && self.parse_keyword(Keyword::PARTITION) { self.parse_parenthesized_identifiers()? } else { vec![] }; // Parse potential version qualifier let version = self.maybe_parse_table_version()?; // Postgres, MSSQL, ClickHouse: table-valued functions: let args = if self.consume_token(&Token::LParen) { Some(self.parse_table_function_args()?) } else { None }; let with_ordinality = self.parse_keywords(&[Keyword::WITH, Keyword::ORDINALITY]); let mut sample = None; if self.dialect.supports_table_sample_before_alias() { if let Some(parsed_sample) = self.maybe_parse_table_sample()? { sample = Some(TableSampleKind::BeforeTableAlias(parsed_sample)); } } let alias = self.maybe_parse_table_alias()?; // MYSQL-specific table hints: let index_hints = if self.dialect.supports_table_hints() { self.maybe_parse(|p| p.parse_table_index_hints())? .unwrap_or(vec![]) } else { vec![] }; // MSSQL-specific table hints: let mut with_hints = vec![]; if self.parse_keyword(Keyword::WITH) { if self.consume_token(&Token::LParen) { with_hints = self.parse_comma_separated(Parser::parse_expr)?; self.expect_token(&Token::RParen)?; } else { // rewind, as WITH may belong to the next statement's CTE self.prev_token(); } }; if !self.dialect.supports_table_sample_before_alias() { if let Some(parsed_sample) = self.maybe_parse_table_sample()? { sample = Some(TableSampleKind::AfterTableAlias(parsed_sample)); } } let mut table = TableFactor::Table { name, alias, args, with_hints, version, partitions, with_ordinality, json_path, sample, index_hints, }; while let Some(kw) = self.parse_one_of_keywords(&[Keyword::PIVOT, Keyword::UNPIVOT]) { table = match kw { Keyword::PIVOT => self.parse_pivot_table_factor(table)?, Keyword::UNPIVOT => self.parse_unpivot_table_factor(table)?, unexpected_keyword => return Err(ParserError::ParserError( format!("Internal parser error: unexpected keyword `{unexpected_keyword}` in pivot/unpivot"), )), } } if self.dialect.supports_match_recognize() && self.parse_keyword(Keyword::MATCH_RECOGNIZE) { table = self.parse_match_recognize(table)?; } Ok(table) } } /// Parse a Snowflake stage reference as a table factor. /// Handles syntax like: `@mystage1 (file_format => 'myformat', pattern => '...')` /// /// See: fn parse_snowflake_stage_table_factor(&mut self) -> Result { // Parse the stage name starting with @ let name = crate::dialect::parse_snowflake_stage_name(self)?; // Parse optional stage options like (file_format => 'myformat', pattern => '...') let args = if self.consume_token(&Token::LParen) { Some(self.parse_table_function_args()?) } else { None }; let alias = self.maybe_parse_table_alias()?; Ok(TableFactor::Table { name, alias, args, with_hints: vec![], version: None, partitions: vec![], with_ordinality: false, json_path: None, sample: None, index_hints: vec![], }) } fn maybe_parse_table_sample(&mut self) -> Result>, ParserError> { let modifier = if self.parse_keyword(Keyword::TABLESAMPLE) { TableSampleModifier::TableSample } else if self.parse_keyword(Keyword::SAMPLE) { TableSampleModifier::Sample } else { return Ok(None); }; self.parse_table_sample(modifier).map(Some) } fn parse_table_sample( &mut self, modifier: TableSampleModifier, ) -> Result, ParserError> { let name = match self.parse_one_of_keywords(&[ Keyword::BERNOULLI, Keyword::ROW, Keyword::SYSTEM, Keyword::BLOCK, ]) { Some(Keyword::BERNOULLI) => Some(TableSampleMethod::Bernoulli), Some(Keyword::ROW) => Some(TableSampleMethod::Row), Some(Keyword::SYSTEM) => Some(TableSampleMethod::System), Some(Keyword::BLOCK) => Some(TableSampleMethod::Block), _ => None, }; let parenthesized = self.consume_token(&Token::LParen); let (quantity, bucket) = if parenthesized && self.parse_keyword(Keyword::BUCKET) { let selected_bucket = self.parse_number_value()?; self.expect_keywords(&[Keyword::OUT, Keyword::OF])?; let total = self.parse_number_value()?; let on = if self.parse_keyword(Keyword::ON) { Some(self.parse_expr()?) } else { None }; ( None, Some(TableSampleBucket { bucket: selected_bucket, total, on, }), ) } else { let value = match self.maybe_parse(|p| p.parse_expr())? { Some(num) => num, None => { let next_token = self.next_token(); if let Token::Word(w) = next_token.token { Expr::Value(Value::Placeholder(w.value).with_span(next_token.span)) } else { return parser_err!( "Expecting number or byte length e.g. 100M", self.peek_token_ref().span.start ); } } }; let unit = if self.parse_keyword(Keyword::ROWS) { Some(TableSampleUnit::Rows) } else if self.parse_keyword(Keyword::PERCENT) { Some(TableSampleUnit::Percent) } else { None }; ( Some(TableSampleQuantity { parenthesized, value, unit, }), None, ) }; if parenthesized { self.expect_token(&Token::RParen)?; } let seed = if self.parse_keyword(Keyword::REPEATABLE) { Some(self.parse_table_sample_seed(TableSampleSeedModifier::Repeatable)?) } else if self.parse_keyword(Keyword::SEED) { Some(self.parse_table_sample_seed(TableSampleSeedModifier::Seed)?) } else { None }; let offset = if self.parse_keyword(Keyword::OFFSET) { Some(self.parse_expr()?) } else { None }; Ok(Box::new(TableSample { modifier, name, quantity, seed, bucket, offset, })) } fn parse_table_sample_seed( &mut self, modifier: TableSampleSeedModifier, ) -> Result { self.expect_token(&Token::LParen)?; let value = self.parse_number_value()?; self.expect_token(&Token::RParen)?; Ok(TableSampleSeed { modifier, value }) } /// Parses `OPENJSON( jsonExpression [ , path ] ) [ ]` clause, /// assuming the `OPENJSON` keyword was already consumed. fn parse_open_json_table_factor(&mut self) -> Result { self.expect_token(&Token::LParen)?; let json_expr = self.parse_expr()?; let json_path = if self.consume_token(&Token::Comma) { Some(self.parse_value()?) } else { None }; self.expect_token(&Token::RParen)?; let columns = if self.parse_keyword(Keyword::WITH) { self.expect_token(&Token::LParen)?; let columns = self.parse_comma_separated(Parser::parse_openjson_table_column_def)?; self.expect_token(&Token::RParen)?; columns } else { Vec::new() }; let alias = self.maybe_parse_table_alias()?; Ok(TableFactor::OpenJsonTable { json_expr, json_path, columns, alias, }) } fn parse_xml_table_factor(&mut self) -> Result { self.expect_token(&Token::LParen)?; let namespaces = if self.parse_keyword(Keyword::XMLNAMESPACES) { self.expect_token(&Token::LParen)?; let namespaces = self.parse_comma_separated(Parser::parse_xml_namespace_definition)?; self.expect_token(&Token::RParen)?; self.expect_token(&Token::Comma)?; namespaces } else { vec![] }; let row_expression = self.parse_expr()?; let passing = self.parse_xml_passing_clause()?; self.expect_keyword_is(Keyword::COLUMNS)?; let columns = self.parse_comma_separated(Parser::parse_xml_table_column)?; self.expect_token(&Token::RParen)?; let alias = self.maybe_parse_table_alias()?; Ok(TableFactor::XmlTable { namespaces, row_expression, passing, columns, alias, }) } fn parse_xml_namespace_definition(&mut self) -> Result { let uri = self.parse_expr()?; self.expect_keyword_is(Keyword::AS)?; let name = self.parse_identifier()?; Ok(XmlNamespaceDefinition { uri, name }) } fn parse_xml_table_column(&mut self) -> Result { let name = self.parse_identifier()?; let option = if self.parse_keyword(Keyword::FOR) { self.expect_keyword(Keyword::ORDINALITY)?; XmlTableColumnOption::ForOrdinality } else { let r#type = self.parse_data_type()?; let mut path = None; let mut default = None; if self.parse_keyword(Keyword::PATH) { path = Some(self.parse_expr()?); } if self.parse_keyword(Keyword::DEFAULT) { default = Some(self.parse_expr()?); } let not_null = self.parse_keywords(&[Keyword::NOT, Keyword::NULL]); if !not_null { // NULL is the default but can be specified explicitly let _ = self.parse_keyword(Keyword::NULL); } XmlTableColumnOption::NamedInfo { r#type, path, default, nullable: !not_null, } }; Ok(XmlTableColumn { name, option }) } fn parse_xml_passing_clause(&mut self) -> Result { let mut arguments = vec![]; if self.parse_keyword(Keyword::PASSING) { loop { let by_value = self.parse_keyword(Keyword::BY) && self.expect_keyword(Keyword::VALUE).is_ok(); let expr = self.parse_expr()?; let alias = if self.parse_keyword(Keyword::AS) { Some(self.parse_identifier()?) } else { None }; arguments.push(XmlPassingArgument { expr, alias, by_value, }); if !self.consume_token(&Token::Comma) { break; } } } Ok(XmlPassingClause { arguments }) } /// Parse a [TableFactor::SemanticView] fn parse_semantic_view_table_factor(&mut self) -> Result { self.expect_keyword(Keyword::SEMANTIC_VIEW)?; self.expect_token(&Token::LParen)?; let name = self.parse_object_name(true)?; // Parse DIMENSIONS, METRICS, FACTS and WHERE clauses in flexible order let mut dimensions = Vec::new(); let mut metrics = Vec::new(); let mut facts = Vec::new(); let mut where_clause = None; while self.peek_token_ref().token != Token::RParen { if self.parse_keyword(Keyword::DIMENSIONS) { if !dimensions.is_empty() { return Err(ParserError::ParserError( "DIMENSIONS clause can only be specified once".to_string(), )); } dimensions = self.parse_comma_separated(Parser::parse_wildcard_expr)?; } else if self.parse_keyword(Keyword::METRICS) { if !metrics.is_empty() { return Err(ParserError::ParserError( "METRICS clause can only be specified once".to_string(), )); } metrics = self.parse_comma_separated(Parser::parse_wildcard_expr)?; } else if self.parse_keyword(Keyword::FACTS) { if !facts.is_empty() { return Err(ParserError::ParserError( "FACTS clause can only be specified once".to_string(), )); } facts = self.parse_comma_separated(Parser::parse_wildcard_expr)?; } else if self.parse_keyword(Keyword::WHERE) { if where_clause.is_some() { return Err(ParserError::ParserError( "WHERE clause can only be specified once".to_string(), )); } where_clause = Some(self.parse_expr()?); } else { let tok = self.peek_token_ref(); return parser_err!( format!( "Expected one of DIMENSIONS, METRICS, FACTS or WHERE, got {}", tok.token ), tok.span.start )?; } } self.expect_token(&Token::RParen)?; let alias = self.maybe_parse_table_alias()?; Ok(TableFactor::SemanticView { name, dimensions, metrics, facts, where_clause, alias, }) } fn parse_match_recognize(&mut self, table: TableFactor) -> Result { self.expect_token(&Token::LParen)?; let partition_by = if self.parse_keywords(&[Keyword::PARTITION, Keyword::BY]) { self.parse_comma_separated(Parser::parse_expr)? } else { vec![] }; let order_by = if self.parse_keywords(&[Keyword::ORDER, Keyword::BY]) { self.parse_comma_separated(Parser::parse_order_by_expr)? } else { vec![] }; let measures = if self.parse_keyword(Keyword::MEASURES) { self.parse_comma_separated(|p| { let expr = p.parse_expr()?; let _ = p.parse_keyword(Keyword::AS); let alias = p.parse_identifier()?; Ok(Measure { expr, alias }) })? } else { vec![] }; let rows_per_match = if self.parse_keywords(&[Keyword::ONE, Keyword::ROW, Keyword::PER, Keyword::MATCH]) { Some(RowsPerMatch::OneRow) } else if self.parse_keywords(&[ Keyword::ALL, Keyword::ROWS, Keyword::PER, Keyword::MATCH, ]) { Some(RowsPerMatch::AllRows( if self.parse_keywords(&[Keyword::SHOW, Keyword::EMPTY, Keyword::MATCHES]) { Some(EmptyMatchesMode::Show) } else if self.parse_keywords(&[ Keyword::OMIT, Keyword::EMPTY, Keyword::MATCHES, ]) { Some(EmptyMatchesMode::Omit) } else if self.parse_keywords(&[ Keyword::WITH, Keyword::UNMATCHED, Keyword::ROWS, ]) { Some(EmptyMatchesMode::WithUnmatched) } else { None }, )) } else { None }; let after_match_skip = if self.parse_keywords(&[Keyword::AFTER, Keyword::MATCH, Keyword::SKIP]) { if self.parse_keywords(&[Keyword::PAST, Keyword::LAST, Keyword::ROW]) { Some(AfterMatchSkip::PastLastRow) } else if self.parse_keywords(&[Keyword::TO, Keyword::NEXT, Keyword::ROW]) { Some(AfterMatchSkip::ToNextRow) } else if self.parse_keywords(&[Keyword::TO, Keyword::FIRST]) { Some(AfterMatchSkip::ToFirst(self.parse_identifier()?)) } else if self.parse_keywords(&[Keyword::TO, Keyword::LAST]) { Some(AfterMatchSkip::ToLast(self.parse_identifier()?)) } else { let found = self.next_token(); return self.expected("after match skip option", found); } } else { None }; self.expect_keyword_is(Keyword::PATTERN)?; let pattern = self.parse_parenthesized(Self::parse_pattern)?; self.expect_keyword_is(Keyword::DEFINE)?; let symbols = self.parse_comma_separated(|p| { let symbol = p.parse_identifier()?; p.expect_keyword_is(Keyword::AS)?; let definition = p.parse_expr()?; Ok(SymbolDefinition { symbol, definition }) })?; self.expect_token(&Token::RParen)?; let alias = self.maybe_parse_table_alias()?; Ok(TableFactor::MatchRecognize { table: Box::new(table), partition_by, order_by, measures, rows_per_match, after_match_skip, pattern, symbols, alias, }) } fn parse_base_pattern(&mut self) -> Result { match self.next_token().token { Token::Caret => Ok(MatchRecognizePattern::Symbol(MatchRecognizeSymbol::Start)), Token::Placeholder(s) if s == "$" => { Ok(MatchRecognizePattern::Symbol(MatchRecognizeSymbol::End)) } Token::LBrace => { self.expect_token(&Token::Minus)?; let symbol = self.parse_identifier().map(MatchRecognizeSymbol::Named)?; self.expect_token(&Token::Minus)?; self.expect_token(&Token::RBrace)?; Ok(MatchRecognizePattern::Exclude(symbol)) } Token::Word(Word { value, quote_style: None, .. }) if value == "PERMUTE" => { self.expect_token(&Token::LParen)?; let symbols = self.parse_comma_separated(|p| { p.parse_identifier().map(MatchRecognizeSymbol::Named) })?; self.expect_token(&Token::RParen)?; Ok(MatchRecognizePattern::Permute(symbols)) } Token::LParen => { let pattern = self.parse_pattern()?; self.expect_token(&Token::RParen)?; Ok(MatchRecognizePattern::Group(Box::new(pattern))) } _ => { self.prev_token(); self.parse_identifier() .map(MatchRecognizeSymbol::Named) .map(MatchRecognizePattern::Symbol) } } } fn parse_repetition_pattern(&mut self) -> Result { let mut pattern = self.parse_base_pattern()?; loop { let token = self.next_token(); let quantifier = match token.token { Token::Mul => RepetitionQuantifier::ZeroOrMore, Token::Plus => RepetitionQuantifier::OneOrMore, Token::Placeholder(s) if s == "?" => RepetitionQuantifier::AtMostOne, Token::LBrace => { // quantifier is a range like {n} or {n,} or {,m} or {n,m} let token = self.next_token(); match token.token { Token::Comma => { let next_token = self.next_token(); let Token::Number(n, _) = next_token.token else { return self.expected("literal number", next_token); }; self.expect_token(&Token::RBrace)?; RepetitionQuantifier::AtMost(Self::parse(n, token.span.start)?) } Token::Number(n, _) if self.consume_token(&Token::Comma) => { let next_token = self.next_token(); match next_token.token { Token::Number(m, _) => { self.expect_token(&Token::RBrace)?; RepetitionQuantifier::Range( Self::parse(n, token.span.start)?, Self::parse(m, token.span.start)?, ) } Token::RBrace => { RepetitionQuantifier::AtLeast(Self::parse(n, token.span.start)?) } _ => { return self.expected("} or upper bound", next_token); } } } Token::Number(n, _) => { self.expect_token(&Token::RBrace)?; RepetitionQuantifier::Exactly(Self::parse(n, token.span.start)?) } _ => return self.expected("quantifier range", token), } } _ => { self.prev_token(); break; } }; pattern = MatchRecognizePattern::Repetition(Box::new(pattern), quantifier); } Ok(pattern) } fn parse_concat_pattern(&mut self) -> Result { let mut patterns = vec![self.parse_repetition_pattern()?]; while !matches!(self.peek_token_ref().token, Token::RParen | Token::Pipe) { patterns.push(self.parse_repetition_pattern()?); } match <[MatchRecognizePattern; 1]>::try_from(patterns) { Ok([pattern]) => Ok(pattern), Err(patterns) => Ok(MatchRecognizePattern::Concat(patterns)), } } fn parse_pattern(&mut self) -> Result { let pattern = self.parse_concat_pattern()?; if self.consume_token(&Token::Pipe) { match self.parse_pattern()? { // flatten nested alternations MatchRecognizePattern::Alternation(mut patterns) => { patterns.insert(0, pattern); Ok(MatchRecognizePattern::Alternation(patterns)) } next => Ok(MatchRecognizePattern::Alternation(vec![pattern, next])), } } else { Ok(pattern) } } /// Parses a the timestamp version specifier (i.e. query historical data) pub fn maybe_parse_table_version(&mut self) -> Result, ParserError> { if self.dialect.supports_table_versioning() { if self.parse_keywords(&[Keyword::FOR, Keyword::SYSTEM_TIME, Keyword::AS, Keyword::OF]) { let expr = self.parse_expr()?; return Ok(Some(TableVersion::ForSystemTimeAsOf(expr))); } else if self.peek_keyword(Keyword::CHANGES) { return self.parse_table_version_changes().map(Some); } else if self.peek_keyword(Keyword::AT) || self.peek_keyword(Keyword::BEFORE) { let func_name = self.parse_object_name(true)?; let func = self.parse_function(func_name)?; return Ok(Some(TableVersion::Function(func))); } else if self.parse_keywords(&[Keyword::TIMESTAMP, Keyword::AS, Keyword::OF]) { let expr = self.parse_expr()?; return Ok(Some(TableVersion::TimestampAsOf(expr))); } else if self.parse_keywords(&[Keyword::VERSION, Keyword::AS, Keyword::OF]) { let expr = Expr::Value(self.parse_number_value()?); return Ok(Some(TableVersion::VersionAsOf(expr))); } } Ok(None) } /// Parses the Snowflake `CHANGES` clause for change tracking queries. /// /// Syntax: /// ```sql /// CHANGES (INFORMATION => DEFAULT) /// AT (TIMESTAMP => ) /// [END (TIMESTAMP => )] /// ``` /// /// fn parse_table_version_changes(&mut self) -> Result { let changes_name = self.parse_object_name(true)?; let changes = self.parse_function(changes_name)?; let at_name = self.parse_object_name(true)?; let at = self.parse_function(at_name)?; let end = if self.peek_keyword(Keyword::END) { let end_name = self.parse_object_name(true)?; Some(self.parse_function(end_name)?) } else { None }; Ok(TableVersion::Changes { changes, at, end }) } /// Parses MySQL's JSON_TABLE column definition. /// For example: `id INT EXISTS PATH '$' DEFAULT '0' ON EMPTY ERROR ON ERROR` pub fn parse_json_table_column_def(&mut self) -> Result { if self.parse_keyword(Keyword::NESTED) { let _has_path_keyword = self.parse_keyword(Keyword::PATH); let path = self.parse_value()?; self.expect_keyword_is(Keyword::COLUMNS)?; let columns = self.parse_parenthesized(|p| { p.parse_comma_separated(Self::parse_json_table_column_def) })?; return Ok(JsonTableColumn::Nested(JsonTableNestedColumn { path, columns, })); } let name = self.parse_identifier()?; if self.parse_keyword(Keyword::FOR) { self.expect_keyword_is(Keyword::ORDINALITY)?; return Ok(JsonTableColumn::ForOrdinality(name)); } let r#type = self.parse_data_type()?; let exists = self.parse_keyword(Keyword::EXISTS); self.expect_keyword_is(Keyword::PATH)?; let path = self.parse_value()?; let mut on_empty = None; let mut on_error = None; while let Some(error_handling) = self.parse_json_table_column_error_handling()? { if self.parse_keyword(Keyword::EMPTY) { on_empty = Some(error_handling); } else { self.expect_keyword_is(Keyword::ERROR)?; on_error = Some(error_handling); } } Ok(JsonTableColumn::Named(JsonTableNamedColumn { name, r#type, path, exists, on_empty, on_error, })) } /// Parses MSSQL's `OPENJSON WITH` column definition. /// /// ```sql /// colName type [ column_path ] [ AS JSON ] /// ``` /// /// Reference: pub fn parse_openjson_table_column_def(&mut self) -> Result { let name = self.parse_identifier()?; let r#type = self.parse_data_type()?; let path = if let Token::SingleQuotedString(path) = self.peek_token().token { self.next_token(); Some(path) } else { None }; let as_json = self.parse_keyword(Keyword::AS); if as_json { self.expect_keyword_is(Keyword::JSON)?; } Ok(OpenJsonTableColumn { name, r#type, path, as_json, }) } fn parse_json_table_column_error_handling( &mut self, ) -> Result, ParserError> { let res = if self.parse_keyword(Keyword::NULL) { JsonTableColumnErrorHandling::Null } else if self.parse_keyword(Keyword::ERROR) { JsonTableColumnErrorHandling::Error } else if self.parse_keyword(Keyword::DEFAULT) { JsonTableColumnErrorHandling::Default(self.parse_value()?) } else { return Ok(None); }; self.expect_keyword_is(Keyword::ON)?; Ok(Some(res)) } /// Parse a derived table factor (a parenthesized subquery), handling optional LATERAL. pub fn parse_derived_table_factor( &mut self, lateral: IsLateral, ) -> Result { let subquery = self.parse_query()?; self.expect_token(&Token::RParen)?; let alias = self.maybe_parse_table_alias()?; // Parse optional SAMPLE clause after alias let sample = self .maybe_parse_table_sample()? .map(TableSampleKind::AfterTableAlias); Ok(TableFactor::Derived { lateral: match lateral { Lateral => true, NotLateral => false, }, subquery, alias, sample, }) } /// Parses an expression with an optional alias /// /// Examples: /// /// ```sql /// SUM(price) AS total_price /// ``` /// ```sql /// SUM(price) /// ``` /// /// Example /// ``` /// # use sqlparser::parser::{Parser, ParserError}; /// # use sqlparser::dialect::GenericDialect; /// # fn main() ->Result<(), ParserError> { /// let sql = r#"SUM("a") as "b""#; /// let mut parser = Parser::new(&GenericDialect).try_with_sql(sql)?; /// let expr_with_alias = parser.parse_expr_with_alias()?; /// assert_eq!(Some("b".to_string()), expr_with_alias.alias.map(|x|x.value)); /// # Ok(()) /// # } pub fn parse_expr_with_alias(&mut self) -> Result { let expr = self.parse_expr()?; let alias = if self.parse_keyword(Keyword::AS) { Some(self.parse_identifier()?) } else { None }; Ok(ExprWithAlias { expr, alias }) } /// Parse an expression followed by an optional alias; Unlike /// [Self::parse_expr_with_alias] the "AS" keyword between the expression /// and the alias is optional. fn parse_expr_with_alias_optional_as_keyword(&mut self) -> Result { let expr = self.parse_expr()?; let alias = self.parse_identifier_optional_alias()?; Ok(ExprWithAlias { expr, alias }) } /// Parses a plain function call with an optional alias for the `PIVOT` clause fn parse_pivot_aggregate_function(&mut self) -> Result { let function_name = match self.next_token().token { Token::Word(w) => Ok(w.value), _ => self.expected_ref("a function identifier", self.peek_token_ref()), }?; let expr = self.parse_function(ObjectName::from(vec![Ident::new(function_name)]))?; let alias = { fn validator(explicit: bool, kw: &Keyword, parser: &mut Parser) -> bool { // ~ for a PIVOT aggregate function the alias must not be a "FOR"; in any dialect kw != &Keyword::FOR && parser.dialect.is_select_item_alias(explicit, kw, parser) } self.parse_optional_alias_inner(None, validator)? }; Ok(ExprWithAlias { expr, alias }) } /// Parse a PIVOT table factor (ClickHouse/Oracle style pivot), returning a TableFactor. pub fn parse_pivot_table_factor( &mut self, table: TableFactor, ) -> Result { self.expect_token(&Token::LParen)?; let aggregate_functions = self.parse_comma_separated(Self::parse_pivot_aggregate_function)?; self.expect_keyword_is(Keyword::FOR)?; let value_column = if self.peek_token_ref().token == Token::LParen { self.parse_parenthesized_column_list_inner(Mandatory, false, |p| { p.parse_subexpr(self.dialect.prec_value(Precedence::Between)) })? } else { vec![self.parse_subexpr(self.dialect.prec_value(Precedence::Between))?] }; self.expect_keyword_is(Keyword::IN)?; self.expect_token(&Token::LParen)?; let value_source = if self.parse_keyword(Keyword::ANY) { let order_by = if self.parse_keywords(&[Keyword::ORDER, Keyword::BY]) { self.parse_comma_separated(Parser::parse_order_by_expr)? } else { vec![] }; PivotValueSource::Any(order_by) } else if self.peek_sub_query() { PivotValueSource::Subquery(self.parse_query()?) } else { PivotValueSource::List( self.parse_comma_separated(Self::parse_expr_with_alias_optional_as_keyword)?, ) }; self.expect_token(&Token::RParen)?; let default_on_null = if self.parse_keywords(&[Keyword::DEFAULT, Keyword::ON, Keyword::NULL]) { self.expect_token(&Token::LParen)?; let expr = self.parse_expr()?; self.expect_token(&Token::RParen)?; Some(expr) } else { None }; self.expect_token(&Token::RParen)?; let alias = self.maybe_parse_table_alias()?; Ok(TableFactor::Pivot { table: Box::new(table), aggregate_functions, value_column, value_source, default_on_null, alias, }) } /// Parse an UNPIVOT table factor, returning a TableFactor. pub fn parse_unpivot_table_factor( &mut self, table: TableFactor, ) -> Result { let null_inclusion = if self.parse_keyword(Keyword::INCLUDE) { self.expect_keyword_is(Keyword::NULLS)?; Some(NullInclusion::IncludeNulls) } else if self.parse_keyword(Keyword::EXCLUDE) { self.expect_keyword_is(Keyword::NULLS)?; Some(NullInclusion::ExcludeNulls) } else { None }; self.expect_token(&Token::LParen)?; let value = self.parse_expr()?; self.expect_keyword_is(Keyword::FOR)?; let name = self.parse_identifier()?; self.expect_keyword_is(Keyword::IN)?; let columns = self.parse_parenthesized_column_list_inner(Mandatory, false, |p| { p.parse_expr_with_alias() })?; self.expect_token(&Token::RParen)?; let alias = self.maybe_parse_table_alias()?; Ok(TableFactor::Unpivot { table: Box::new(table), value, null_inclusion, name, columns, alias, }) } /// Parse a JOIN constraint (`NATURAL`, `ON `, `USING (...)`, or no constraint). pub fn parse_join_constraint(&mut self, natural: bool) -> Result { if natural { Ok(JoinConstraint::Natural) } else if self.parse_keyword(Keyword::ON) { let constraint = self.parse_expr()?; Ok(JoinConstraint::On(constraint)) } else if self.parse_keyword(Keyword::USING) { let columns = self.parse_parenthesized_qualified_column_list(Mandatory, false)?; Ok(JoinConstraint::Using(columns)) } else { Ok(JoinConstraint::None) //self.expected_ref("ON, or USING after JOIN", self.peek_token_ref()) } } /// Parse a GRANT statement. pub fn parse_grant(&mut self) -> Result { let (privileges, objects) = self.parse_grant_deny_revoke_privileges_objects()?; self.expect_keyword_is(Keyword::TO)?; let grantees = self.parse_grantees()?; let with_grant_option = self.parse_keywords(&[Keyword::WITH, Keyword::GRANT, Keyword::OPTION]); let current_grants = if self.parse_keywords(&[Keyword::COPY, Keyword::CURRENT, Keyword::GRANTS]) { Some(CurrentGrantsKind::CopyCurrentGrants) } else if self.parse_keywords(&[Keyword::REVOKE, Keyword::CURRENT, Keyword::GRANTS]) { Some(CurrentGrantsKind::RevokeCurrentGrants) } else { None }; let as_grantor = if self.parse_keywords(&[Keyword::AS]) { Some(self.parse_identifier()?) } else { None }; let granted_by = if self.parse_keywords(&[Keyword::GRANTED, Keyword::BY]) { Some(self.parse_identifier()?) } else { None }; Ok(Grant { privileges, objects, grantees, with_grant_option, as_grantor, granted_by, current_grants, }) } fn parse_grantees(&mut self) -> Result, ParserError> { let mut values = vec![]; let mut grantee_type = GranteesType::None; loop { let new_grantee_type = if self.parse_keyword(Keyword::ROLE) { GranteesType::Role } else if self.parse_keyword(Keyword::USER) { GranteesType::User } else if self.parse_keyword(Keyword::SHARE) { GranteesType::Share } else if self.parse_keyword(Keyword::GROUP) { GranteesType::Group } else if self.parse_keyword(Keyword::PUBLIC) { GranteesType::Public } else if self.parse_keywords(&[Keyword::DATABASE, Keyword::ROLE]) { GranteesType::DatabaseRole } else if self.parse_keywords(&[Keyword::APPLICATION, Keyword::ROLE]) { GranteesType::ApplicationRole } else if self.parse_keyword(Keyword::APPLICATION) { GranteesType::Application } else { grantee_type.clone() // keep from previous iteraton, if not specified }; if self .dialect .get_reserved_grantees_types() .contains(&new_grantee_type) { self.prev_token(); } else { grantee_type = new_grantee_type; } let grantee = if grantee_type == GranteesType::Public { Grantee { grantee_type: grantee_type.clone(), name: None, } } else { let mut name = self.parse_grantee_name()?; if self.consume_token(&Token::Colon) { // Redshift supports namespace prefix for external users and groups: // : or : // https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-iam-access-control-native-idp.html let ident = self.parse_identifier()?; if let GranteeName::ObjectName(namespace) = name { name = GranteeName::ObjectName(ObjectName::from(vec![Ident::new( format!("{namespace}:{ident}"), )])); }; } Grantee { grantee_type: grantee_type.clone(), name: Some(name), } }; values.push(grantee); if !self.consume_token(&Token::Comma) { break; } } Ok(values) } /// Parse privileges and optional target objects for GRANT/DENY/REVOKE statements. pub fn parse_grant_deny_revoke_privileges_objects( &mut self, ) -> Result<(Privileges, Option), ParserError> { let privileges = if self.parse_keyword(Keyword::ALL) { Privileges::All { with_privileges_keyword: self.parse_keyword(Keyword::PRIVILEGES), } } else { let actions = self.parse_actions_list()?; Privileges::Actions(actions) }; let objects = if self.parse_keyword(Keyword::ON) { if self.parse_keywords(&[Keyword::ALL, Keyword::TABLES, Keyword::IN, Keyword::SCHEMA]) { Some(GrantObjects::AllTablesInSchema { schemas: self.parse_comma_separated(|p| p.parse_object_name(false))?, }) } else if self.parse_keywords(&[ Keyword::ALL, Keyword::EXTERNAL, Keyword::TABLES, Keyword::IN, Keyword::SCHEMA, ]) { Some(GrantObjects::AllExternalTablesInSchema { schemas: self.parse_comma_separated(|p| p.parse_object_name(false))?, }) } else if self.parse_keywords(&[ Keyword::ALL, Keyword::VIEWS, Keyword::IN, Keyword::SCHEMA, ]) { Some(GrantObjects::AllViewsInSchema { schemas: self.parse_comma_separated(|p| p.parse_object_name(false))?, }) } else if self.parse_keywords(&[ Keyword::ALL, Keyword::MATERIALIZED, Keyword::VIEWS, Keyword::IN, Keyword::SCHEMA, ]) { Some(GrantObjects::AllMaterializedViewsInSchema { schemas: self.parse_comma_separated(|p| p.parse_object_name(false))?, }) } else if self.parse_keywords(&[ Keyword::ALL, Keyword::FUNCTIONS, Keyword::IN, Keyword::SCHEMA, ]) { Some(GrantObjects::AllFunctionsInSchema { schemas: self.parse_comma_separated(|p| p.parse_object_name(false))?, }) } else if self.parse_keywords(&[ Keyword::FUTURE, Keyword::SCHEMAS, Keyword::IN, Keyword::DATABASE, ]) { Some(GrantObjects::FutureSchemasInDatabase { databases: self.parse_comma_separated(|p| p.parse_object_name(false))?, }) } else if self.parse_keywords(&[ Keyword::FUTURE, Keyword::TABLES, Keyword::IN, Keyword::SCHEMA, ]) { Some(GrantObjects::FutureTablesInSchema { schemas: self.parse_comma_separated(|p| p.parse_object_name(false))?, }) } else if self.parse_keywords(&[ Keyword::FUTURE, Keyword::EXTERNAL, Keyword::TABLES, Keyword::IN, Keyword::SCHEMA, ]) { Some(GrantObjects::FutureExternalTablesInSchema { schemas: self.parse_comma_separated(|p| p.parse_object_name(false))?, }) } else if self.parse_keywords(&[ Keyword::FUTURE, Keyword::VIEWS, Keyword::IN, Keyword::SCHEMA, ]) { Some(GrantObjects::FutureViewsInSchema { schemas: self.parse_comma_separated(|p| p.parse_object_name(false))?, }) } else if self.parse_keywords(&[ Keyword::FUTURE, Keyword::MATERIALIZED, Keyword::VIEWS, Keyword::IN, Keyword::SCHEMA, ]) { Some(GrantObjects::FutureMaterializedViewsInSchema { schemas: self.parse_comma_separated(|p| p.parse_object_name(false))?, }) } else if self.parse_keywords(&[ Keyword::ALL, Keyword::SEQUENCES, Keyword::IN, Keyword::SCHEMA, ]) { Some(GrantObjects::AllSequencesInSchema { schemas: self.parse_comma_separated(|p| p.parse_object_name(false))?, }) } else if self.parse_keywords(&[ Keyword::FUTURE, Keyword::SEQUENCES, Keyword::IN, Keyword::SCHEMA, ]) { Some(GrantObjects::FutureSequencesInSchema { schemas: self.parse_comma_separated(|p| p.parse_object_name(false))?, }) } else if self.parse_keywords(&[Keyword::RESOURCE, Keyword::MONITOR]) { Some(GrantObjects::ResourceMonitors( self.parse_comma_separated(|p| p.parse_object_name(false))?, )) } else if self.parse_keywords(&[Keyword::COMPUTE, Keyword::POOL]) { Some(GrantObjects::ComputePools( self.parse_comma_separated(|p| p.parse_object_name(false))?, )) } else if self.parse_keywords(&[Keyword::FAILOVER, Keyword::GROUP]) { Some(GrantObjects::FailoverGroup( self.parse_comma_separated(|p| p.parse_object_name(false))?, )) } else if self.parse_keywords(&[Keyword::REPLICATION, Keyword::GROUP]) { Some(GrantObjects::ReplicationGroup( self.parse_comma_separated(|p| p.parse_object_name(false))?, )) } else if self.parse_keywords(&[Keyword::EXTERNAL, Keyword::VOLUME]) { Some(GrantObjects::ExternalVolumes( self.parse_comma_separated(|p| p.parse_object_name(false))?, )) } else { let object_type = self.parse_one_of_keywords(&[ Keyword::SEQUENCE, Keyword::DATABASE, Keyword::SCHEMA, Keyword::TABLE, Keyword::VIEW, Keyword::WAREHOUSE, Keyword::INTEGRATION, Keyword::VIEW, Keyword::WAREHOUSE, Keyword::INTEGRATION, Keyword::USER, Keyword::CONNECTION, Keyword::PROCEDURE, Keyword::FUNCTION, ]); let objects = self.parse_comma_separated(|p| p.parse_object_name_inner(false, true)); match object_type { Some(Keyword::DATABASE) => Some(GrantObjects::Databases(objects?)), Some(Keyword::SCHEMA) => Some(GrantObjects::Schemas(objects?)), Some(Keyword::SEQUENCE) => Some(GrantObjects::Sequences(objects?)), Some(Keyword::WAREHOUSE) => Some(GrantObjects::Warehouses(objects?)), Some(Keyword::INTEGRATION) => Some(GrantObjects::Integrations(objects?)), Some(Keyword::VIEW) => Some(GrantObjects::Views(objects?)), Some(Keyword::USER) => Some(GrantObjects::Users(objects?)), Some(Keyword::CONNECTION) => Some(GrantObjects::Connections(objects?)), kw @ (Some(Keyword::PROCEDURE) | Some(Keyword::FUNCTION)) => { if let Some(name) = objects?.first() { self.parse_grant_procedure_or_function(name, &kw)? } else { self.expected_ref("procedure or function name", self.peek_token_ref())? } } Some(Keyword::TABLE) | None => Some(GrantObjects::Tables(objects?)), Some(unexpected_keyword) => return Err(ParserError::ParserError( format!("Internal parser error: unexpected keyword `{unexpected_keyword}` in grant objects"), )), } } } else { None }; Ok((privileges, objects)) } fn parse_grant_procedure_or_function( &mut self, name: &ObjectName, kw: &Option, ) -> Result, ParserError> { let arg_types = if self.consume_token(&Token::LParen) { let list = self.parse_comma_separated0(Self::parse_data_type, Token::RParen)?; self.expect_token(&Token::RParen)?; list } else { vec![] }; match kw { Some(Keyword::PROCEDURE) => Ok(Some(GrantObjects::Procedure { name: name.clone(), arg_types, })), Some(Keyword::FUNCTION) => Ok(Some(GrantObjects::Function { name: name.clone(), arg_types, })), _ => self.expected_ref("procedure or function keywords", self.peek_token_ref())?, } } /// Parse a single grantable permission/action (used within GRANT statements). pub fn parse_grant_permission(&mut self) -> Result { fn parse_columns(parser: &mut Parser) -> Result>, ParserError> { let columns = parser.parse_parenthesized_column_list(Optional, false)?; if columns.is_empty() { Ok(None) } else { Ok(Some(columns)) } } // Multi-word privileges if self.parse_keywords(&[Keyword::IMPORTED, Keyword::PRIVILEGES]) { Ok(Action::ImportedPrivileges) } else if self.parse_keywords(&[Keyword::ADD, Keyword::SEARCH, Keyword::OPTIMIZATION]) { Ok(Action::AddSearchOptimization) } else if self.parse_keywords(&[Keyword::ATTACH, Keyword::LISTING]) { Ok(Action::AttachListing) } else if self.parse_keywords(&[Keyword::ATTACH, Keyword::POLICY]) { Ok(Action::AttachPolicy) } else if self.parse_keywords(&[Keyword::BIND, Keyword::SERVICE, Keyword::ENDPOINT]) { Ok(Action::BindServiceEndpoint) } else if self.parse_keywords(&[Keyword::DATABASE, Keyword::ROLE]) { let role = self.parse_object_name(false)?; Ok(Action::DatabaseRole { role }) } else if self.parse_keywords(&[Keyword::EVOLVE, Keyword::SCHEMA]) { Ok(Action::EvolveSchema) } else if self.parse_keywords(&[Keyword::IMPORT, Keyword::SHARE]) { Ok(Action::ImportShare) } else if self.parse_keywords(&[Keyword::MANAGE, Keyword::VERSIONS]) { Ok(Action::ManageVersions) } else if self.parse_keywords(&[Keyword::MANAGE, Keyword::RELEASES]) { Ok(Action::ManageReleases) } else if self.parse_keywords(&[Keyword::OVERRIDE, Keyword::SHARE, Keyword::RESTRICTIONS]) { Ok(Action::OverrideShareRestrictions) } else if self.parse_keywords(&[ Keyword::PURCHASE, Keyword::DATA, Keyword::EXCHANGE, Keyword::LISTING, ]) { Ok(Action::PurchaseDataExchangeListing) } else if self.parse_keywords(&[Keyword::RESOLVE, Keyword::ALL]) { Ok(Action::ResolveAll) } else if self.parse_keywords(&[Keyword::READ, Keyword::SESSION]) { Ok(Action::ReadSession) // Single-word privileges } else if self.parse_keyword(Keyword::APPLY) { let apply_type = self.parse_action_apply_type()?; Ok(Action::Apply { apply_type }) } else if self.parse_keyword(Keyword::APPLYBUDGET) { Ok(Action::ApplyBudget) } else if self.parse_keyword(Keyword::AUDIT) { Ok(Action::Audit) } else if self.parse_keyword(Keyword::CONNECT) { Ok(Action::Connect) } else if self.parse_keyword(Keyword::CREATE) { let obj_type = self.maybe_parse_action_create_object_type(); Ok(Action::Create { obj_type }) } else if self.parse_keyword(Keyword::DELETE) { Ok(Action::Delete) } else if self.parse_keyword(Keyword::EXEC) { let obj_type = self.maybe_parse_action_execute_obj_type(); Ok(Action::Exec { obj_type }) } else if self.parse_keyword(Keyword::EXECUTE) { let obj_type = self.maybe_parse_action_execute_obj_type(); Ok(Action::Execute { obj_type }) } else if self.parse_keyword(Keyword::FAILOVER) { Ok(Action::Failover) } else if self.parse_keyword(Keyword::INSERT) { Ok(Action::Insert { columns: parse_columns(self)?, }) } else if self.parse_keyword(Keyword::MANAGE) { let manage_type = self.parse_action_manage_type()?; Ok(Action::Manage { manage_type }) } else if self.parse_keyword(Keyword::MODIFY) { let modify_type = self.parse_action_modify_type(); Ok(Action::Modify { modify_type }) } else if self.parse_keyword(Keyword::MONITOR) { let monitor_type = self.parse_action_monitor_type(); Ok(Action::Monitor { monitor_type }) } else if self.parse_keyword(Keyword::OPERATE) { Ok(Action::Operate) } else if self.parse_keyword(Keyword::REFERENCES) { Ok(Action::References { columns: parse_columns(self)?, }) } else if self.parse_keyword(Keyword::READ) { Ok(Action::Read) } else if self.parse_keyword(Keyword::REPLICATE) { Ok(Action::Replicate) } else if self.parse_keyword(Keyword::ROLE) { let role = self.parse_object_name(false)?; Ok(Action::Role { role }) } else if self.parse_keyword(Keyword::SELECT) { Ok(Action::Select { columns: parse_columns(self)?, }) } else if self.parse_keyword(Keyword::TEMPORARY) { Ok(Action::Temporary) } else if self.parse_keyword(Keyword::TRIGGER) { Ok(Action::Trigger) } else if self.parse_keyword(Keyword::TRUNCATE) { Ok(Action::Truncate) } else if self.parse_keyword(Keyword::UPDATE) { Ok(Action::Update { columns: parse_columns(self)?, }) } else if self.parse_keyword(Keyword::USAGE) { Ok(Action::Usage) } else if self.parse_keyword(Keyword::OWNERSHIP) { Ok(Action::Ownership) } else if self.parse_keyword(Keyword::DROP) { Ok(Action::Drop) } else { self.expected_ref("a privilege keyword", self.peek_token_ref())? } } fn maybe_parse_action_create_object_type(&mut self) -> Option { // Multi-word object types if self.parse_keywords(&[Keyword::APPLICATION, Keyword::PACKAGE]) { Some(ActionCreateObjectType::ApplicationPackage) } else if self.parse_keywords(&[Keyword::COMPUTE, Keyword::POOL]) { Some(ActionCreateObjectType::ComputePool) } else if self.parse_keywords(&[Keyword::DATA, Keyword::EXCHANGE, Keyword::LISTING]) { Some(ActionCreateObjectType::DataExchangeListing) } else if self.parse_keywords(&[Keyword::EXTERNAL, Keyword::VOLUME]) { Some(ActionCreateObjectType::ExternalVolume) } else if self.parse_keywords(&[Keyword::FAILOVER, Keyword::GROUP]) { Some(ActionCreateObjectType::FailoverGroup) } else if self.parse_keywords(&[Keyword::NETWORK, Keyword::POLICY]) { Some(ActionCreateObjectType::NetworkPolicy) } else if self.parse_keywords(&[Keyword::ORGANIZATION, Keyword::LISTING]) { Some(ActionCreateObjectType::OrganiationListing) } else if self.parse_keywords(&[Keyword::REPLICATION, Keyword::GROUP]) { Some(ActionCreateObjectType::ReplicationGroup) } // Single-word object types else if self.parse_keyword(Keyword::ACCOUNT) { Some(ActionCreateObjectType::Account) } else if self.parse_keyword(Keyword::APPLICATION) { Some(ActionCreateObjectType::Application) } else if self.parse_keyword(Keyword::DATABASE) { Some(ActionCreateObjectType::Database) } else if self.parse_keyword(Keyword::INTEGRATION) { Some(ActionCreateObjectType::Integration) } else if self.parse_keyword(Keyword::ROLE) { Some(ActionCreateObjectType::Role) } else if self.parse_keyword(Keyword::SCHEMA) { Some(ActionCreateObjectType::Schema) } else if self.parse_keyword(Keyword::SHARE) { Some(ActionCreateObjectType::Share) } else if self.parse_keyword(Keyword::USER) { Some(ActionCreateObjectType::User) } else if self.parse_keyword(Keyword::WAREHOUSE) { Some(ActionCreateObjectType::Warehouse) } else { None } } fn parse_action_apply_type(&mut self) -> Result { if self.parse_keywords(&[Keyword::AGGREGATION, Keyword::POLICY]) { Ok(ActionApplyType::AggregationPolicy) } else if self.parse_keywords(&[Keyword::AUTHENTICATION, Keyword::POLICY]) { Ok(ActionApplyType::AuthenticationPolicy) } else if self.parse_keywords(&[Keyword::JOIN, Keyword::POLICY]) { Ok(ActionApplyType::JoinPolicy) } else if self.parse_keywords(&[Keyword::MASKING, Keyword::POLICY]) { Ok(ActionApplyType::MaskingPolicy) } else if self.parse_keywords(&[Keyword::PACKAGES, Keyword::POLICY]) { Ok(ActionApplyType::PackagesPolicy) } else if self.parse_keywords(&[Keyword::PASSWORD, Keyword::POLICY]) { Ok(ActionApplyType::PasswordPolicy) } else if self.parse_keywords(&[Keyword::PROJECTION, Keyword::POLICY]) { Ok(ActionApplyType::ProjectionPolicy) } else if self.parse_keywords(&[Keyword::ROW, Keyword::ACCESS, Keyword::POLICY]) { Ok(ActionApplyType::RowAccessPolicy) } else if self.parse_keywords(&[Keyword::SESSION, Keyword::POLICY]) { Ok(ActionApplyType::SessionPolicy) } else if self.parse_keyword(Keyword::TAG) { Ok(ActionApplyType::Tag) } else { self.expected_ref("GRANT APPLY type", self.peek_token_ref()) } } fn maybe_parse_action_execute_obj_type(&mut self) -> Option { if self.parse_keywords(&[Keyword::DATA, Keyword::METRIC, Keyword::FUNCTION]) { Some(ActionExecuteObjectType::DataMetricFunction) } else if self.parse_keywords(&[Keyword::MANAGED, Keyword::ALERT]) { Some(ActionExecuteObjectType::ManagedAlert) } else if self.parse_keywords(&[Keyword::MANAGED, Keyword::TASK]) { Some(ActionExecuteObjectType::ManagedTask) } else if self.parse_keyword(Keyword::ALERT) { Some(ActionExecuteObjectType::Alert) } else if self.parse_keyword(Keyword::TASK) { Some(ActionExecuteObjectType::Task) } else { None } } fn parse_action_manage_type(&mut self) -> Result { if self.parse_keywords(&[Keyword::ACCOUNT, Keyword::SUPPORT, Keyword::CASES]) { Ok(ActionManageType::AccountSupportCases) } else if self.parse_keywords(&[Keyword::EVENT, Keyword::SHARING]) { Ok(ActionManageType::EventSharing) } else if self.parse_keywords(&[Keyword::LISTING, Keyword::AUTO, Keyword::FULFILLMENT]) { Ok(ActionManageType::ListingAutoFulfillment) } else if self.parse_keywords(&[Keyword::ORGANIZATION, Keyword::SUPPORT, Keyword::CASES]) { Ok(ActionManageType::OrganizationSupportCases) } else if self.parse_keywords(&[Keyword::USER, Keyword::SUPPORT, Keyword::CASES]) { Ok(ActionManageType::UserSupportCases) } else if self.parse_keyword(Keyword::GRANTS) { Ok(ActionManageType::Grants) } else if self.parse_keyword(Keyword::WAREHOUSES) { Ok(ActionManageType::Warehouses) } else { self.expected_ref("GRANT MANAGE type", self.peek_token_ref()) } } fn parse_action_modify_type(&mut self) -> Option { if self.parse_keywords(&[Keyword::LOG, Keyword::LEVEL]) { Some(ActionModifyType::LogLevel) } else if self.parse_keywords(&[Keyword::TRACE, Keyword::LEVEL]) { Some(ActionModifyType::TraceLevel) } else if self.parse_keywords(&[Keyword::SESSION, Keyword::LOG, Keyword::LEVEL]) { Some(ActionModifyType::SessionLogLevel) } else if self.parse_keywords(&[Keyword::SESSION, Keyword::TRACE, Keyword::LEVEL]) { Some(ActionModifyType::SessionTraceLevel) } else { None } } fn parse_action_monitor_type(&mut self) -> Option { if self.parse_keyword(Keyword::EXECUTION) { Some(ActionMonitorType::Execution) } else if self.parse_keyword(Keyword::SECURITY) { Some(ActionMonitorType::Security) } else if self.parse_keyword(Keyword::USAGE) { Some(ActionMonitorType::Usage) } else { None } } /// Parse a grantee name, possibly with a host qualifier (user@host). pub fn parse_grantee_name(&mut self) -> Result { let mut name = self.parse_object_name(false)?; if self.dialect.supports_user_host_grantee() && name.0.len() == 1 && name.0[0].as_ident().is_some() && self.consume_token(&Token::AtSign) { let user = name.0.pop().unwrap().as_ident().unwrap().clone(); let host = self.parse_identifier()?; Ok(GranteeName::UserHost { user, host }) } else { Ok(GranteeName::ObjectName(name)) } } /// Parse [`Statement::Deny`] pub fn parse_deny(&mut self) -> Result { self.expect_keyword(Keyword::DENY)?; let (privileges, objects) = self.parse_grant_deny_revoke_privileges_objects()?; let objects = match objects { Some(o) => o, None => { return parser_err!( "DENY statements must specify an object", self.peek_token_ref().span.start ) } }; self.expect_keyword_is(Keyword::TO)?; let grantees = self.parse_grantees()?; let cascade = self.parse_cascade_option(); let granted_by = if self.parse_keywords(&[Keyword::AS]) { Some(self.parse_identifier()?) } else { None }; Ok(Statement::Deny(DenyStatement { privileges, objects, grantees, cascade, granted_by, })) } /// Parse a REVOKE statement pub fn parse_revoke(&mut self) -> Result { let (privileges, objects) = self.parse_grant_deny_revoke_privileges_objects()?; self.expect_keyword_is(Keyword::FROM)?; let grantees = self.parse_grantees()?; let granted_by = if self.parse_keywords(&[Keyword::GRANTED, Keyword::BY]) { Some(self.parse_identifier()?) } else { None }; let cascade = self.parse_cascade_option(); Ok(Revoke { privileges, objects, grantees, granted_by, cascade, }) } /// Parse an REPLACE statement pub fn parse_replace( &mut self, replace_token: TokenWithSpan, ) -> Result { if !dialect_of!(self is MySqlDialect | GenericDialect) { return parser_err!( "Unsupported statement REPLACE", self.peek_token_ref().span.start ); } let mut insert = self.parse_insert(replace_token)?; if let Statement::Insert(Insert { replace_into, .. }) = &mut insert { *replace_into = true; } Ok(insert) } /// Parse an INSERT statement, returning a `Box`ed SetExpr /// /// This is used to reduce the size of the stack frames in debug builds fn parse_insert_setexpr_boxed( &mut self, insert_token: TokenWithSpan, ) -> Result, ParserError> { Ok(Box::new(SetExpr::Insert(self.parse_insert(insert_token)?))) } /// Parse an INSERT statement pub fn parse_insert(&mut self, insert_token: TokenWithSpan) -> Result { let optimizer_hints = self.maybe_parse_optimizer_hints()?; let or = self.parse_conflict_clause(); let priority = if !dialect_of!(self is MySqlDialect | GenericDialect) { None } else if self.parse_keyword(Keyword::LOW_PRIORITY) { Some(MysqlInsertPriority::LowPriority) } else if self.parse_keyword(Keyword::DELAYED) { Some(MysqlInsertPriority::Delayed) } else if self.parse_keyword(Keyword::HIGH_PRIORITY) { Some(MysqlInsertPriority::HighPriority) } else { None }; let ignore = dialect_of!(self is MySqlDialect | GenericDialect) && self.parse_keyword(Keyword::IGNORE); let replace_into = false; let overwrite = self.parse_keyword(Keyword::OVERWRITE); let into = self.parse_keyword(Keyword::INTO); let local = self.parse_keyword(Keyword::LOCAL); if self.parse_keyword(Keyword::DIRECTORY) { let path = self.parse_literal_string()?; let file_format = if self.parse_keywords(&[Keyword::STORED, Keyword::AS]) { Some(self.parse_file_format()?) } else { None }; let source = self.parse_query()?; Ok(Statement::Directory { local, path, overwrite, file_format, source, }) } else { // Hive lets you put table here regardless let table = self.parse_keyword(Keyword::TABLE); let table_object = self.parse_table_object()?; let table_alias = if self.dialect.supports_insert_table_alias() && !self.peek_sub_query() && self .peek_one_of_keywords(&[Keyword::DEFAULT, Keyword::VALUES]) .is_none() { if self.parse_keyword(Keyword::AS) { Some(TableAliasWithoutColumns { explicit: true, alias: self.parse_identifier()?, }) } else { self.maybe_parse(|parser| parser.parse_identifier())? .map(|alias| TableAliasWithoutColumns { explicit: false, alias, }) } } else { None }; let is_mysql = dialect_of!(self is MySqlDialect); let (columns, partitioned, after_columns, output, source, assignments) = if self .parse_keywords(&[Keyword::DEFAULT, Keyword::VALUES]) { (vec![], None, vec![], None, None, vec![]) } else { let (columns, partitioned, after_columns) = if !self.peek_subquery_start() { let columns = self.parse_parenthesized_qualified_column_list(Optional, is_mysql)?; let partitioned = self.parse_insert_partition()?; // Hive allows you to specify columns after partitions as well if you want. let after_columns = if dialect_of!(self is HiveDialect) { self.parse_parenthesized_column_list(Optional, false)? } else { vec![] }; (columns, partitioned, after_columns) } else { Default::default() }; let output = self.maybe_parse_output_clause()?; let (source, assignments) = if self.peek_keyword(Keyword::FORMAT) || self.peek_keyword(Keyword::SETTINGS) { (None, vec![]) } else if self.dialect.supports_insert_set() && self.parse_keyword(Keyword::SET) { (None, self.parse_comma_separated(Parser::parse_assignment)?) } else { (Some(self.parse_query()?), vec![]) }; ( columns, partitioned, after_columns, output, source, assignments, ) }; let (format_clause, settings) = if self.dialect.supports_insert_format() { // Settings always comes before `FORMAT` for ClickHouse: // let settings = self.parse_settings()?; let format = if self.parse_keyword(Keyword::FORMAT) { Some(self.parse_input_format_clause()?) } else { None }; (format, settings) } else { Default::default() }; let insert_alias = if dialect_of!(self is MySqlDialect | GenericDialect) && self.parse_keyword(Keyword::AS) { let row_alias = self.parse_object_name(false)?; let col_aliases = Some(self.parse_parenthesized_column_list(Optional, false)?); Some(InsertAliases { row_alias, col_aliases, }) } else { None }; let on = if self.parse_keyword(Keyword::ON) { if self.parse_keyword(Keyword::CONFLICT) { let conflict_target = if self.parse_keywords(&[Keyword::ON, Keyword::CONSTRAINT]) { Some(ConflictTarget::OnConstraint(self.parse_object_name(false)?)) } else if self.peek_token_ref().token == Token::LParen { Some(ConflictTarget::Columns( self.parse_parenthesized_column_list(IsOptional::Mandatory, false)?, )) } else { None }; self.expect_keyword_is(Keyword::DO)?; let action = if self.parse_keyword(Keyword::NOTHING) { OnConflictAction::DoNothing } else { self.expect_keyword_is(Keyword::UPDATE)?; self.expect_keyword_is(Keyword::SET)?; let assignments = self.parse_comma_separated(Parser::parse_assignment)?; let selection = if self.parse_keyword(Keyword::WHERE) { Some(self.parse_expr()?) } else { None }; OnConflictAction::DoUpdate(DoUpdate { assignments, selection, }) }; Some(OnInsert::OnConflict(OnConflict { conflict_target, action, })) } else { self.expect_keyword_is(Keyword::DUPLICATE)?; self.expect_keyword_is(Keyword::KEY)?; self.expect_keyword_is(Keyword::UPDATE)?; let l = self.parse_comma_separated(Parser::parse_assignment)?; Some(OnInsert::DuplicateKeyUpdate(l)) } } else { None }; let returning = if self.parse_keyword(Keyword::RETURNING) { Some(self.parse_comma_separated(Parser::parse_select_item)?) } else { None }; Ok(Insert { insert_token: insert_token.into(), optimizer_hints, or, table: table_object, table_alias, ignore, into, overwrite, partitioned, columns, after_columns, source, assignments, has_table_keyword: table, on, returning, output, replace_into, priority, insert_alias, settings, format_clause, multi_table_insert_type: None, multi_table_into_clauses: vec![], multi_table_when_clauses: vec![], multi_table_else_clause: None, } .into()) } } /// Parses input format clause used for ClickHouse. /// /// pub fn parse_input_format_clause(&mut self) -> Result { let ident = self.parse_identifier()?; let values = self .maybe_parse(|p| p.parse_comma_separated(|p| p.parse_expr()))? .unwrap_or_default(); Ok(InputFormatClause { ident, values }) } /// Returns true if the immediate tokens look like the /// beginning of a subquery. `(SELECT ...` fn peek_subquery_start(&mut self) -> bool { matches!( self.peek_tokens_ref(), [ TokenWithSpan { token: Token::LParen, .. }, TokenWithSpan { token: Token::Word(Word { keyword: Keyword::SELECT, .. }), .. }, ] ) } /// Returns true if the immediate tokens look like the /// beginning of a subquery possibly preceded by CTEs; /// i.e. `(WITH ...` or `(SELECT ...`. fn peek_subquery_or_cte_start(&mut self) -> bool { matches!( self.peek_tokens_ref(), [ TokenWithSpan { token: Token::LParen, .. }, TokenWithSpan { token: Token::Word(Word { keyword: Keyword::SELECT | Keyword::WITH, .. }), .. }, ] ) } fn parse_conflict_clause(&mut self) -> Option { if self.parse_keywords(&[Keyword::OR, Keyword::REPLACE]) { Some(SqliteOnConflict::Replace) } else if self.parse_keywords(&[Keyword::OR, Keyword::ROLLBACK]) { Some(SqliteOnConflict::Rollback) } else if self.parse_keywords(&[Keyword::OR, Keyword::ABORT]) { Some(SqliteOnConflict::Abort) } else if self.parse_keywords(&[Keyword::OR, Keyword::FAIL]) { Some(SqliteOnConflict::Fail) } else if self.parse_keywords(&[Keyword::OR, Keyword::IGNORE]) { Some(SqliteOnConflict::Ignore) } else if self.parse_keyword(Keyword::REPLACE) { Some(SqliteOnConflict::Replace) } else { None } } /// Parse an optional `PARTITION (...)` clause for INSERT statements. pub fn parse_insert_partition(&mut self) -> Result>, ParserError> { if self.parse_keyword(Keyword::PARTITION) { self.expect_token(&Token::LParen)?; let partition_cols = Some(self.parse_comma_separated(Parser::parse_expr)?); self.expect_token(&Token::RParen)?; Ok(partition_cols) } else { Ok(None) } } /// Parse optional Hive `INPUTFORMAT ... SERDE ...` clause used by LOAD DATA. pub fn parse_load_data_table_format( &mut self, ) -> Result, ParserError> { if self.parse_keyword(Keyword::INPUTFORMAT) { let input_format = self.parse_expr()?; self.expect_keyword_is(Keyword::SERDE)?; let serde = self.parse_expr()?; Ok(Some(HiveLoadDataFormat { input_format, serde, })) } else { Ok(None) } } /// Parse an UPDATE statement, returning a `Box`ed SetExpr /// /// This is used to reduce the size of the stack frames in debug builds fn parse_update_setexpr_boxed( &mut self, update_token: TokenWithSpan, ) -> Result, ParserError> { Ok(Box::new(SetExpr::Update(self.parse_update(update_token)?))) } /// Parse an `UPDATE` statement and return `Statement::Update`. pub fn parse_update(&mut self, update_token: TokenWithSpan) -> Result { let optimizer_hints = self.maybe_parse_optimizer_hints()?; let or = self.parse_conflict_clause(); let table = self.parse_table_and_joins()?; let from_before_set = if self.parse_keyword(Keyword::FROM) { Some(UpdateTableFromKind::BeforeSet( self.parse_table_with_joins()?, )) } else { None }; self.expect_keyword(Keyword::SET)?; let assignments = self.parse_comma_separated(Parser::parse_assignment)?; let output = self.maybe_parse_output_clause()?; let from = if from_before_set.is_none() && self.parse_keyword(Keyword::FROM) { Some(UpdateTableFromKind::AfterSet( self.parse_table_with_joins()?, )) } else { from_before_set }; let selection = if self.parse_keyword(Keyword::WHERE) { Some(self.parse_expr()?) } else { None }; let returning = if self.parse_keyword(Keyword::RETURNING) { Some(self.parse_comma_separated(Parser::parse_select_item)?) } else { None }; let order_by = if self.dialect.supports_update_order_by() && self.parse_keywords(&[Keyword::ORDER, Keyword::BY]) { self.parse_comma_separated(Parser::parse_order_by_expr)? } else { vec![] }; let limit = if self.parse_keyword(Keyword::LIMIT) { Some(self.parse_expr()?) } else { None }; Ok(Update { update_token: update_token.into(), optimizer_hints, table, assignments, from, selection, returning, output, or, order_by, limit, } .into()) } /// Parse a `var = expr` assignment, used in an UPDATE statement pub fn parse_assignment(&mut self) -> Result { let target = self.parse_assignment_target()?; self.expect_token(&Token::Eq)?; let value = self.parse_expr()?; Ok(Assignment { target, value }) } /// Parse the left-hand side of an assignment, used in an UPDATE statement pub fn parse_assignment_target(&mut self) -> Result { if self.consume_token(&Token::LParen) { let columns = self.parse_comma_separated(|p| p.parse_object_name(false))?; self.expect_token(&Token::RParen)?; Ok(AssignmentTarget::Tuple(columns)) } else { let column = self.parse_object_name(false)?; Ok(AssignmentTarget::ColumnName(column)) } } /// Parse a single function argument, handling named and unnamed variants. pub fn parse_function_args(&mut self) -> Result { let arg = if self.dialect.supports_named_fn_args_with_expr_name() { self.maybe_parse(|p| { let name = p.parse_expr()?; let operator = p.parse_function_named_arg_operator()?; let arg = p.parse_wildcard_expr()?.into(); Ok(FunctionArg::ExprNamed { name, arg, operator, }) })? } else { self.maybe_parse(|p| { let name = p.parse_identifier()?; let operator = p.parse_function_named_arg_operator()?; let arg = p.parse_wildcard_expr()?.into(); Ok(FunctionArg::Named { name, arg, operator, }) })? }; if let Some(arg) = arg { return Ok(arg); } let wildcard_expr = self.parse_wildcard_expr()?; let arg_expr: FunctionArgExpr = match wildcard_expr { Expr::Wildcard(ref token) if self.dialect.supports_select_wildcard_exclude() => { // Support `* EXCLUDE(col1, col2, ...)` inside function calls (e.g. Snowflake's // `HASH(* EXCLUDE(col))`). Parse the options the same way SELECT items do. let opts = self.parse_wildcard_additional_options(token.0.clone())?; if opts.opt_exclude.is_some() || opts.opt_except.is_some() || opts.opt_replace.is_some() || opts.opt_rename.is_some() || opts.opt_ilike.is_some() { FunctionArgExpr::WildcardWithOptions(opts) } else { wildcard_expr.into() } } other => other.into(), }; Ok(FunctionArg::Unnamed(arg_expr)) } fn parse_function_named_arg_operator(&mut self) -> Result { if self.parse_keyword(Keyword::VALUE) { return Ok(FunctionArgOperator::Value); } let tok = self.next_token(); match tok.token { Token::RArrow if self.dialect.supports_named_fn_args_with_rarrow_operator() => { Ok(FunctionArgOperator::RightArrow) } Token::Eq if self.dialect.supports_named_fn_args_with_eq_operator() => { Ok(FunctionArgOperator::Equals) } Token::Assignment if self .dialect .supports_named_fn_args_with_assignment_operator() => { Ok(FunctionArgOperator::Assignment) } Token::Colon if self.dialect.supports_named_fn_args_with_colon_operator() => { Ok(FunctionArgOperator::Colon) } _ => { self.prev_token(); self.expected("argument operator", tok) } } } /// Parse an optional, comma-separated list of function arguments (consumes closing paren). pub fn parse_optional_args(&mut self) -> Result, ParserError> { if self.consume_token(&Token::RParen) { Ok(vec![]) } else { let args = self.parse_comma_separated(Parser::parse_function_args)?; self.expect_token(&Token::RParen)?; Ok(args) } } fn parse_table_function_args(&mut self) -> Result { if self.consume_token(&Token::RParen) { return Ok(TableFunctionArgs { args: vec![], settings: None, }); } let mut args = vec![]; let settings = loop { if let Some(settings) = self.parse_settings()? { break Some(settings); } args.push(self.parse_function_args()?); if self.is_parse_comma_separated_end() { break None; } }; self.expect_token(&Token::RParen)?; Ok(TableFunctionArgs { args, settings }) } /// Parses a potentially empty list of arguments to a function /// (including the closing parenthesis). /// /// Examples: /// ```sql /// FIRST_VALUE(x ORDER BY 1,2,3); /// FIRST_VALUE(x IGNORE NULL); /// ``` fn parse_function_argument_list(&mut self) -> Result { let mut clauses = vec![]; // Handle clauses that may exist with an empty argument list if let Some(null_clause) = self.parse_json_null_clause() { clauses.push(FunctionArgumentClause::JsonNullClause(null_clause)); } if let Some(json_returning_clause) = self.maybe_parse_json_returning_clause()? { clauses.push(FunctionArgumentClause::JsonReturningClause( json_returning_clause, )); } if self.consume_token(&Token::RParen) { return Ok(FunctionArgumentList { duplicate_treatment: None, args: vec![], clauses, }); } let duplicate_treatment = self.parse_duplicate_treatment()?; let args = self.parse_comma_separated(Parser::parse_function_args)?; if self.dialect.supports_window_function_null_treatment_arg() { if let Some(null_treatment) = self.parse_null_treatment()? { clauses.push(FunctionArgumentClause::IgnoreOrRespectNulls(null_treatment)); } } if self.parse_keywords(&[Keyword::ORDER, Keyword::BY]) { clauses.push(FunctionArgumentClause::OrderBy( self.parse_comma_separated(Parser::parse_order_by_expr)?, )); } if self.parse_keyword(Keyword::LIMIT) { clauses.push(FunctionArgumentClause::Limit(self.parse_expr()?)); } if dialect_of!(self is GenericDialect | BigQueryDialect) && self.parse_keyword(Keyword::HAVING) { let kind = match self.expect_one_of_keywords(&[Keyword::MIN, Keyword::MAX])? { Keyword::MIN => HavingBoundKind::Min, Keyword::MAX => HavingBoundKind::Max, unexpected_keyword => return Err(ParserError::ParserError( format!("Internal parser error: unexpected keyword `{unexpected_keyword}` in having bound"), )), }; clauses.push(FunctionArgumentClause::Having(HavingBound( kind, self.parse_expr()?, ))) } if dialect_of!(self is GenericDialect | MySqlDialect) && self.parse_keyword(Keyword::SEPARATOR) { clauses.push(FunctionArgumentClause::Separator(self.parse_value()?)); } if let Some(on_overflow) = self.parse_listagg_on_overflow()? { clauses.push(FunctionArgumentClause::OnOverflow(on_overflow)); } if let Some(null_clause) = self.parse_json_null_clause() { clauses.push(FunctionArgumentClause::JsonNullClause(null_clause)); } if let Some(json_returning_clause) = self.maybe_parse_json_returning_clause()? { clauses.push(FunctionArgumentClause::JsonReturningClause( json_returning_clause, )); } self.expect_token(&Token::RParen)?; Ok(FunctionArgumentList { duplicate_treatment, args, clauses, }) } fn parse_json_null_clause(&mut self) -> Option { if self.parse_keywords(&[Keyword::ABSENT, Keyword::ON, Keyword::NULL]) { Some(JsonNullClause::AbsentOnNull) } else if self.parse_keywords(&[Keyword::NULL, Keyword::ON, Keyword::NULL]) { Some(JsonNullClause::NullOnNull) } else { None } } fn maybe_parse_json_returning_clause( &mut self, ) -> Result, ParserError> { if self.parse_keyword(Keyword::RETURNING) { let data_type = self.parse_data_type()?; Ok(Some(JsonReturningClause { data_type })) } else { Ok(None) } } fn parse_duplicate_treatment(&mut self) -> Result, ParserError> { let loc = self.peek_token_ref().span.start; match ( self.parse_keyword(Keyword::ALL), self.parse_keyword(Keyword::DISTINCT), ) { (true, false) => Ok(Some(DuplicateTreatment::All)), (false, true) => Ok(Some(DuplicateTreatment::Distinct)), (false, false) => Ok(None), (true, true) => parser_err!("Cannot specify both ALL and DISTINCT".to_string(), loc), } } /// Parse a comma-delimited list of projections after SELECT pub fn parse_select_item(&mut self) -> Result { let prefix = self .parse_one_of_keywords( self.dialect .get_reserved_keywords_for_select_item_operator(), ) .map(|keyword| Ident::new(format!("{keyword:?}"))); match self.parse_wildcard_expr()? { Expr::QualifiedWildcard(prefix, token) => Ok(SelectItem::QualifiedWildcard( SelectItemQualifiedWildcardKind::ObjectName(prefix), self.parse_wildcard_additional_options(token.0)?, )), Expr::Wildcard(token) => Ok(SelectItem::Wildcard( self.parse_wildcard_additional_options(token.0)?, )), Expr::Identifier(v) if v.value.to_lowercase() == "from" && v.quote_style.is_none() => { parser_err!( format!("Expected an expression, found: {}", v), self.peek_token_ref().span.start ) } Expr::BinaryOp { left, op: BinaryOperator::Eq, right, } if self.dialect.supports_eq_alias_assignment() && matches!(left.as_ref(), Expr::Identifier(_)) => { let Expr::Identifier(alias) = *left else { return parser_err!( "BUG: expected identifier expression as alias", self.peek_token_ref().span.start ); }; Ok(SelectItem::ExprWithAlias { expr: *right, alias, }) } expr if self.dialect.supports_select_expr_star() && self.consume_tokens(&[Token::Period, Token::Mul]) => { let wildcard_token = self.get_previous_token().clone(); Ok(SelectItem::QualifiedWildcard( SelectItemQualifiedWildcardKind::Expr(expr), self.parse_wildcard_additional_options(wildcard_token)?, )) } expr if self.dialect.supports_select_item_multi_column_alias() && self.peek_keyword(Keyword::AS) && self.peek_nth_token(1).token == Token::LParen => { self.expect_keyword(Keyword::AS)?; self.expect_token(&Token::LParen)?; let aliases = self.parse_comma_separated(|p| p.parse_identifier())?; self.expect_token(&Token::RParen)?; Ok(SelectItem::ExprWithAliases { expr: maybe_prefixed_expr(expr, prefix), aliases, }) } expr => self .maybe_parse_select_item_alias() .map(|alias| match alias { Some(alias) => SelectItem::ExprWithAlias { expr: maybe_prefixed_expr(expr, prefix), alias, }, None => SelectItem::UnnamedExpr(maybe_prefixed_expr(expr, prefix)), }), } } /// Parse an [`WildcardAdditionalOptions`] information for wildcard select items. /// /// If it is not possible to parse it, will return an option. pub fn parse_wildcard_additional_options( &mut self, wildcard_token: TokenWithSpan, ) -> Result { let opt_ilike = if self.dialect.supports_select_wildcard_ilike() { self.parse_optional_select_item_ilike()? } else { None }; let opt_exclude = if opt_ilike.is_none() && self.dialect.supports_select_wildcard_exclude() { self.parse_optional_select_item_exclude()? } else { None }; let opt_except = if self.dialect.supports_select_wildcard_except() { self.parse_optional_select_item_except()? } else { None }; let opt_replace = if self.dialect.supports_select_wildcard_replace() { self.parse_optional_select_item_replace()? } else { None }; let opt_rename = if self.dialect.supports_select_wildcard_rename() { self.parse_optional_select_item_rename()? } else { None }; let opt_alias = if self.dialect.supports_select_wildcard_with_alias() { self.maybe_parse_select_item_alias()? } else { None }; Ok(WildcardAdditionalOptions { wildcard_token: wildcard_token.into(), opt_ilike, opt_exclude, opt_except, opt_rename, opt_replace, opt_alias, }) } /// Parse an [`Ilike`](IlikeSelectItem) information for wildcard select items. /// /// If it is not possible to parse it, will return an option. pub fn parse_optional_select_item_ilike( &mut self, ) -> Result, ParserError> { let opt_ilike = if self.parse_keyword(Keyword::ILIKE) { let next_token = self.next_token(); let pattern = match next_token.token { Token::SingleQuotedString(s) => s, _ => return self.expected("ilike pattern", next_token), }; Some(IlikeSelectItem { pattern }) } else { None }; Ok(opt_ilike) } /// Parse an [`Exclude`](ExcludeSelectItem) information for wildcard select items. /// /// If it is not possible to parse it, will return an option. pub fn parse_optional_select_item_exclude( &mut self, ) -> Result, ParserError> { let opt_exclude = if self.parse_keyword(Keyword::EXCLUDE) { if self.consume_token(&Token::LParen) { let columns = self.parse_comma_separated(|parser| parser.parse_object_name(false))?; self.expect_token(&Token::RParen)?; Some(ExcludeSelectItem::Multiple(columns)) } else { let column = self.parse_object_name(false)?; Some(ExcludeSelectItem::Single(column)) } } else { None }; Ok(opt_exclude) } /// Parse an [`Except`](ExceptSelectItem) information for wildcard select items. /// /// If it is not possible to parse it, will return an option. pub fn parse_optional_select_item_except( &mut self, ) -> Result, ParserError> { let opt_except = if self.parse_keyword(Keyword::EXCEPT) { if self.peek_token_ref().token == Token::LParen { let idents = self.parse_parenthesized_column_list(Mandatory, false)?; match &idents[..] { [] => { return self.expected_ref( "at least one column should be parsed by the expect clause", self.peek_token_ref(), )?; } [first, idents @ ..] => Some(ExceptSelectItem { first_element: first.clone(), additional_elements: idents.to_vec(), }), } } else { // Clickhouse allows EXCEPT column_name let ident = self.parse_identifier()?; Some(ExceptSelectItem { first_element: ident, additional_elements: vec![], }) } } else { None }; Ok(opt_except) } /// Parse a [`Rename`](RenameSelectItem) information for wildcard select items. pub fn parse_optional_select_item_rename( &mut self, ) -> Result, ParserError> { let opt_rename = if self.parse_keyword(Keyword::RENAME) { if self.consume_token(&Token::LParen) { let idents = self.parse_comma_separated(|parser| parser.parse_identifier_with_alias())?; self.expect_token(&Token::RParen)?; Some(RenameSelectItem::Multiple(idents)) } else { let ident = self.parse_identifier_with_alias()?; Some(RenameSelectItem::Single(ident)) } } else { None }; Ok(opt_rename) } /// Parse a [`Replace`](ReplaceSelectItem) information for wildcard select items. pub fn parse_optional_select_item_replace( &mut self, ) -> Result, ParserError> { let opt_replace = if self.parse_keyword(Keyword::REPLACE) { if self.consume_token(&Token::LParen) { let items = self.parse_comma_separated(|parser| { Ok(Box::new(parser.parse_replace_elements()?)) })?; self.expect_token(&Token::RParen)?; Some(ReplaceSelectItem { items }) } else { let tok = self.next_token(); return self.expected("( after REPLACE but", tok); } } else { None }; Ok(opt_replace) } /// Parse a single element of a `REPLACE (...)` select-item clause. pub fn parse_replace_elements(&mut self) -> Result { let expr = self.parse_expr()?; let as_keyword = self.parse_keyword(Keyword::AS); let ident = self.parse_identifier()?; Ok(ReplaceSelectElement { expr, column_name: ident, as_keyword, }) } /// Parse ASC or DESC, returns an Option with true if ASC, false of DESC or `None` if none of /// them. pub fn parse_asc_desc(&mut self) -> Option { if self.parse_keyword(Keyword::ASC) { Some(true) } else if self.parse_keyword(Keyword::DESC) { Some(false) } else { None } } /// Parse an [OrderByExpr] expression. pub fn parse_order_by_expr(&mut self) -> Result { self.parse_order_by_expr_inner(false) .map(|(order_by, _)| order_by) } /// Parse an [IndexColumn]. pub fn parse_create_index_expr(&mut self) -> Result { self.parse_order_by_expr_inner(true) .map(|(column, operator_class)| IndexColumn { column, operator_class, }) } fn parse_order_by_expr_inner( &mut self, with_operator_class: bool, ) -> Result<(OrderByExpr, Option), ParserError> { let expr = self.parse_expr()?; let operator_class: Option = if with_operator_class { // We check that if non of the following keywords are present, then we parse an // identifier as operator class. if self .peek_one_of_keywords(&[Keyword::ASC, Keyword::DESC, Keyword::NULLS, Keyword::WITH]) .is_some() { None } else { self.maybe_parse(|parser| parser.parse_object_name(false))? } } else { None }; let options = self.parse_order_by_options()?; let with_fill = if self.dialect.supports_with_fill() && self.parse_keywords(&[Keyword::WITH, Keyword::FILL]) { Some(self.parse_with_fill()?) } else { None }; Ok(( OrderByExpr { expr, options, with_fill, }, operator_class, )) } fn parse_order_by_options(&mut self) -> Result { let asc = self.parse_asc_desc(); let nulls_first = if self.parse_keywords(&[Keyword::NULLS, Keyword::FIRST]) { Some(true) } else if self.parse_keywords(&[Keyword::NULLS, Keyword::LAST]) { Some(false) } else { None }; Ok(OrderByOptions { asc, nulls_first }) } // Parse a WITH FILL clause (ClickHouse dialect) // that follow the WITH FILL keywords in a ORDER BY clause /// Parse a `WITH FILL` clause used in ORDER BY (ClickHouse dialect). pub fn parse_with_fill(&mut self) -> Result { let from = if self.parse_keyword(Keyword::FROM) { Some(self.parse_expr()?) } else { None }; let to = if self.parse_keyword(Keyword::TO) { Some(self.parse_expr()?) } else { None }; let step = if self.parse_keyword(Keyword::STEP) { Some(self.parse_expr()?) } else { None }; Ok(WithFill { from, to, step }) } /// Parse a set of comma separated INTERPOLATE expressions (ClickHouse dialect) /// that follow the INTERPOLATE keyword in an ORDER BY clause with the WITH FILL modifier pub fn parse_interpolations(&mut self) -> Result, ParserError> { if !self.parse_keyword(Keyword::INTERPOLATE) { return Ok(None); } if self.consume_token(&Token::LParen) { let interpolations = self.parse_comma_separated0(|p| p.parse_interpolation(), Token::RParen)?; self.expect_token(&Token::RParen)?; // INTERPOLATE () and INTERPOLATE ( ... ) variants return Ok(Some(Interpolate { exprs: Some(interpolations), })); } // INTERPOLATE Ok(Some(Interpolate { exprs: None })) } /// Parse a INTERPOLATE expression (ClickHouse dialect) pub fn parse_interpolation(&mut self) -> Result { let column = self.parse_identifier()?; let expr = if self.parse_keyword(Keyword::AS) { Some(self.parse_expr()?) } else { None }; Ok(InterpolateExpr { column, expr }) } /// Parse a TOP clause, MSSQL equivalent of LIMIT, /// that follows after `SELECT [DISTINCT]`. pub fn parse_top(&mut self) -> Result { let quantity = if self.consume_token(&Token::LParen) { let quantity = self.parse_expr()?; self.expect_token(&Token::RParen)?; Some(TopQuantity::Expr(quantity)) } else { let next_token = self.next_token(); let quantity = match next_token.token { Token::Number(s, _) => Self::parse::(s, next_token.span.start)?, _ => self.expected("literal int", next_token)?, }; Some(TopQuantity::Constant(quantity)) }; let percent = self.parse_keyword(Keyword::PERCENT); let with_ties = self.parse_keywords(&[Keyword::WITH, Keyword::TIES]); Ok(Top { with_ties, percent, quantity, }) } /// Parse a LIMIT clause pub fn parse_limit(&mut self) -> Result, ParserError> { if self.parse_keyword(Keyword::ALL) { Ok(None) } else { Ok(Some(self.parse_expr()?)) } } /// Parse an OFFSET clause pub fn parse_offset(&mut self) -> Result { let value = self.parse_expr()?; let rows = if self.parse_keyword(Keyword::ROW) { OffsetRows::Row } else if self.parse_keyword(Keyword::ROWS) { OffsetRows::Rows } else { OffsetRows::None }; Ok(Offset { value, rows }) } /// Parse a FETCH clause pub fn parse_fetch(&mut self) -> Result { let _ = self.parse_one_of_keywords(&[Keyword::FIRST, Keyword::NEXT]); let (quantity, percent) = if self .parse_one_of_keywords(&[Keyword::ROW, Keyword::ROWS]) .is_some() { (None, false) } else { let quantity = Expr::Value(self.parse_value()?); let percent = self.parse_keyword(Keyword::PERCENT); let _ = self.parse_one_of_keywords(&[Keyword::ROW, Keyword::ROWS]); (Some(quantity), percent) }; let with_ties = if self.parse_keyword(Keyword::ONLY) { false } else { self.parse_keywords(&[Keyword::WITH, Keyword::TIES]) }; Ok(Fetch { with_ties, percent, quantity, }) } /// Parse a FOR UPDATE/FOR SHARE clause pub fn parse_lock(&mut self) -> Result { let lock_type = match self.expect_one_of_keywords(&[Keyword::UPDATE, Keyword::SHARE])? { Keyword::UPDATE => LockType::Update, Keyword::SHARE => LockType::Share, unexpected_keyword => return Err(ParserError::ParserError( format!("Internal parser error: expected any of {{UPDATE, SHARE}}, got {unexpected_keyword:?}"), )), }; let of = if self.parse_keyword(Keyword::OF) { Some(self.parse_object_name(false)?) } else { None }; let nonblock = if self.parse_keyword(Keyword::NOWAIT) { Some(NonBlock::Nowait) } else if self.parse_keywords(&[Keyword::SKIP, Keyword::LOCKED]) { Some(NonBlock::SkipLocked) } else { None }; Ok(LockClause { lock_type, of, nonblock, }) } /// Parse a PostgreSQL `LOCK` statement. pub fn parse_lock_statement(&mut self) -> Result { self.expect_keyword(Keyword::LOCK)?; if self.peek_keyword(Keyword::TABLES) { return self.expected_ref("TABLE or a table name", self.peek_token_ref()); } let _ = self.parse_keyword(Keyword::TABLE); let tables = self.parse_comma_separated(Parser::parse_lock_table_target)?; let lock_mode = if self.parse_keyword(Keyword::IN) { let lock_mode = self.parse_lock_table_mode()?; self.expect_keyword(Keyword::MODE)?; Some(lock_mode) } else { None }; let nowait = self.parse_keyword(Keyword::NOWAIT); Ok(Lock { tables, lock_mode, nowait, }) } fn parse_lock_table_target(&mut self) -> Result { let only = self.parse_keyword(Keyword::ONLY); let name = self.parse_object_name(false)?; let has_asterisk = self.consume_token(&Token::Mul); Ok(LockTableTarget { name, only, has_asterisk, }) } fn parse_lock_table_mode(&mut self) -> Result { if self.parse_keywords(&[Keyword::ACCESS, Keyword::SHARE]) { Ok(LockTableMode::AccessShare) } else if self.parse_keywords(&[Keyword::ACCESS, Keyword::EXCLUSIVE]) { Ok(LockTableMode::AccessExclusive) } else if self.parse_keywords(&[Keyword::ROW, Keyword::SHARE]) { Ok(LockTableMode::RowShare) } else if self.parse_keywords(&[Keyword::ROW, Keyword::EXCLUSIVE]) { Ok(LockTableMode::RowExclusive) } else if self.parse_keywords(&[Keyword::SHARE, Keyword::UPDATE, Keyword::EXCLUSIVE]) { Ok(LockTableMode::ShareUpdateExclusive) } else if self.parse_keywords(&[Keyword::SHARE, Keyword::ROW, Keyword::EXCLUSIVE]) { Ok(LockTableMode::ShareRowExclusive) } else if self.parse_keyword(Keyword::SHARE) { Ok(LockTableMode::Share) } else if self.parse_keyword(Keyword::EXCLUSIVE) { Ok(LockTableMode::Exclusive) } else { self.expected_ref("a PostgreSQL LOCK TABLE mode", self.peek_token_ref()) } } /// Parse a VALUES clause pub fn parse_values( &mut self, allow_empty: bool, value_keyword: bool, ) -> Result { let mut explicit_row = false; let rows = self.parse_comma_separated(|parser| { if parser.parse_keyword(Keyword::ROW) { explicit_row = true; } Ok(Parens { opening_token: parser.expect_token(&Token::LParen)?.into(), content: if allow_empty && parser.peek_token_ref().token == Token::RParen { vec![] } else { parser.parse_comma_separated(Parser::parse_expr)? }, closing_token: parser.expect_token(&Token::RParen)?.into(), }) })?; Ok(Values { explicit_row, rows, value_keyword, }) } /// Parse a 'START TRANSACTION' statement pub fn parse_start_transaction(&mut self) -> Result { self.expect_keyword_is(Keyword::TRANSACTION)?; Ok(Statement::StartTransaction { modes: self.parse_transaction_modes()?, begin: false, transaction: Some(BeginTransactionKind::Transaction), modifier: None, statements: vec![], exception: None, has_end_keyword: false, }) } /// Parse a transaction modifier keyword that can follow a `BEGIN` statement. pub(crate) fn parse_transaction_modifier(&mut self) -> Option { if !self.dialect.supports_start_transaction_modifier() { None } else if self.parse_keyword(Keyword::DEFERRED) { Some(TransactionModifier::Deferred) } else if self.parse_keyword(Keyword::IMMEDIATE) { Some(TransactionModifier::Immediate) } else if self.parse_keyword(Keyword::EXCLUSIVE) { Some(TransactionModifier::Exclusive) } else if self.parse_keyword(Keyword::TRY) { Some(TransactionModifier::Try) } else if self.parse_keyword(Keyword::CATCH) { Some(TransactionModifier::Catch) } else { None } } /// Parse a 'BEGIN' statement pub fn parse_begin(&mut self) -> Result { let modifier = self.parse_transaction_modifier(); let transaction = match self.parse_one_of_keywords(&[Keyword::TRANSACTION, Keyword::WORK, Keyword::TRAN]) { Some(Keyword::TRANSACTION) => Some(BeginTransactionKind::Transaction), Some(Keyword::WORK) => Some(BeginTransactionKind::Work), Some(Keyword::TRAN) => Some(BeginTransactionKind::Tran), _ => None, }; Ok(Statement::StartTransaction { modes: self.parse_transaction_modes()?, begin: true, transaction, modifier, statements: vec![], exception: None, has_end_keyword: false, }) } /// Parse a 'BEGIN ... EXCEPTION ... END' block pub fn parse_begin_exception_end(&mut self) -> Result { let statements = self.parse_statement_list(&[Keyword::EXCEPTION, Keyword::END])?; let exception = if self.parse_keyword(Keyword::EXCEPTION) { let mut when = Vec::new(); // We can have multiple `WHEN` arms so we consume all cases until `END` while !self.peek_keyword(Keyword::END) { self.expect_keyword(Keyword::WHEN)?; // Each `WHEN` case can have one or more conditions, e.g. // WHEN EXCEPTION_1 [OR EXCEPTION_2] THEN // So we parse identifiers until the `THEN` keyword. let mut idents = Vec::new(); while !self.parse_keyword(Keyword::THEN) { let ident = self.parse_identifier()?; idents.push(ident); self.maybe_parse(|p| p.expect_keyword(Keyword::OR))?; } let statements = self.parse_statement_list(&[Keyword::WHEN, Keyword::END])?; when.push(ExceptionWhen { idents, statements }); } Some(when) } else { None }; self.expect_keyword(Keyword::END)?; Ok(Statement::StartTransaction { begin: true, statements, exception, has_end_keyword: true, transaction: None, modifier: None, modes: Default::default(), }) } /// Parse an 'END' statement pub fn parse_end(&mut self) -> Result { let modifier = if !self.dialect.supports_end_transaction_modifier() { None } else if self.parse_keyword(Keyword::TRY) { Some(TransactionModifier::Try) } else if self.parse_keyword(Keyword::CATCH) { Some(TransactionModifier::Catch) } else { None }; Ok(Statement::Commit { chain: self.parse_commit_rollback_chain()?, end: true, modifier, }) } /// Parse a list of transaction modes pub fn parse_transaction_modes(&mut self) -> Result, ParserError> { let mut modes = vec![]; let mut required = false; loop { let mode = if self.parse_keywords(&[Keyword::ISOLATION, Keyword::LEVEL]) { let iso_level = if self.parse_keywords(&[Keyword::READ, Keyword::UNCOMMITTED]) { TransactionIsolationLevel::ReadUncommitted } else if self.parse_keywords(&[Keyword::READ, Keyword::COMMITTED]) { TransactionIsolationLevel::ReadCommitted } else if self.parse_keywords(&[Keyword::REPEATABLE, Keyword::READ]) { TransactionIsolationLevel::RepeatableRead } else if self.parse_keyword(Keyword::SERIALIZABLE) { TransactionIsolationLevel::Serializable } else if self.parse_keyword(Keyword::SNAPSHOT) { TransactionIsolationLevel::Snapshot } else { self.expected_ref("isolation level", self.peek_token_ref())? }; TransactionMode::IsolationLevel(iso_level) } else if self.parse_keywords(&[Keyword::READ, Keyword::ONLY]) { TransactionMode::AccessMode(TransactionAccessMode::ReadOnly) } else if self.parse_keywords(&[Keyword::READ, Keyword::WRITE]) { TransactionMode::AccessMode(TransactionAccessMode::ReadWrite) } else if required { self.expected_ref("transaction mode", self.peek_token_ref())? } else { break; }; modes.push(mode); // ANSI requires a comma after each transaction mode, but // PostgreSQL, for historical reasons, does not. We follow // PostgreSQL in making the comma optional, since that is strictly // more general. required = self.consume_token(&Token::Comma); } Ok(modes) } /// Parse a 'COMMIT' statement pub fn parse_commit(&mut self) -> Result { Ok(Statement::Commit { chain: self.parse_commit_rollback_chain()?, end: false, modifier: None, }) } /// Parse a 'ROLLBACK' statement pub fn parse_rollback(&mut self) -> Result { let chain = self.parse_commit_rollback_chain()?; let savepoint = self.parse_rollback_savepoint()?; Ok(Statement::Rollback { chain, savepoint }) } /// Parse an optional `AND [NO] CHAIN` clause for `COMMIT` and `ROLLBACK` statements pub fn parse_commit_rollback_chain(&mut self) -> Result { let _ = self.parse_one_of_keywords(&[Keyword::TRANSACTION, Keyword::WORK, Keyword::TRAN]); if self.parse_keyword(Keyword::AND) { let chain = !self.parse_keyword(Keyword::NO); self.expect_keyword_is(Keyword::CHAIN)?; Ok(chain) } else { Ok(false) } } /// Parse an optional 'TO SAVEPOINT savepoint_name' clause for ROLLBACK statements pub fn parse_rollback_savepoint(&mut self) -> Result, ParserError> { if self.parse_keyword(Keyword::TO) { let _ = self.parse_keyword(Keyword::SAVEPOINT); let savepoint = self.parse_identifier()?; Ok(Some(savepoint)) } else { Ok(None) } } /// Parse a 'RAISERROR' statement pub fn parse_raiserror(&mut self) -> Result { self.expect_token(&Token::LParen)?; let message = Box::new(self.parse_expr()?); self.expect_token(&Token::Comma)?; let severity = Box::new(self.parse_expr()?); self.expect_token(&Token::Comma)?; let state = Box::new(self.parse_expr()?); let arguments = if self.consume_token(&Token::Comma) { self.parse_comma_separated(Parser::parse_expr)? } else { vec![] }; self.expect_token(&Token::RParen)?; let options = if self.parse_keyword(Keyword::WITH) { self.parse_comma_separated(Parser::parse_raiserror_option)? } else { vec![] }; Ok(Statement::RaisError { message, severity, state, arguments, options, }) } /// Parse a single `RAISERROR` option pub fn parse_raiserror_option(&mut self) -> Result { match self.expect_one_of_keywords(&[Keyword::LOG, Keyword::NOWAIT, Keyword::SETERROR])? { Keyword::LOG => Ok(RaisErrorOption::Log), Keyword::NOWAIT => Ok(RaisErrorOption::NoWait), Keyword::SETERROR => Ok(RaisErrorOption::SetError), _ => self.expected_ref( "LOG, NOWAIT OR SETERROR raiserror option", self.peek_token_ref(), ), } } /// Parse a MSSQL `THROW` statement. /// /// See [Statement::Throw] pub fn parse_throw(&mut self) -> Result { self.expect_keyword_is(Keyword::THROW)?; let error_number = self.maybe_parse(|p| p.parse_expr().map(Box::new))?; let (message, state) = if error_number.is_some() { self.expect_token(&Token::Comma)?; let message = Box::new(self.parse_expr()?); self.expect_token(&Token::Comma)?; let state = Box::new(self.parse_expr()?); (Some(message), Some(state)) } else { (None, None) }; Ok(ThrowStatement { error_number, message, state, }) } /// Parse a SQL `DEALLOCATE` statement pub fn parse_deallocate(&mut self) -> Result { let prepare = self.parse_keyword(Keyword::PREPARE); let name = self.parse_identifier()?; Ok(Statement::Deallocate { name, prepare }) } /// Parse a SQL `EXECUTE` statement pub fn parse_execute(&mut self) -> Result { let immediate = self.dialect.supports_execute_immediate() && self.parse_keyword(Keyword::IMMEDIATE); // When `EXEC` is immediately followed by `(`, the content is a dynamic-SQL // expression — e.g. `EXEC (@sql)`, `EXEC ('SELECT ...')`, or // `EXEC ('SELECT ... FROM ' + @tbl + ' WHERE ...')`. // Skip name parsing; the expression ends up in `parameters` via the // `has_parentheses` path below, consistent with `EXECUTE IMMEDIATE `. let name = if immediate || matches!(self.peek_token_ref().token, Token::LParen) { None } else { Some(self.parse_object_name(false)?) }; let has_parentheses = self.consume_token(&Token::LParen); let end_kws = &[Keyword::USING, Keyword::OUTPUT, Keyword::DEFAULT]; let end_token = match (has_parentheses, self.peek_token().token) { (true, _) => Token::RParen, (false, Token::EOF) => Token::EOF, (false, Token::Word(w)) if end_kws.contains(&w.keyword) => Token::Word(w), (false, _) => Token::SemiColon, }; let parameters = self.parse_comma_separated0(Parser::parse_expr, end_token)?; if has_parentheses { self.expect_token(&Token::RParen)?; } let into = if self.parse_keyword(Keyword::INTO) { self.parse_comma_separated(Self::parse_identifier)? } else { vec![] }; let using = if self.parse_keyword(Keyword::USING) { self.parse_comma_separated(Self::parse_expr_with_alias)? } else { vec![] }; let output = self.parse_keyword(Keyword::OUTPUT); let default = self.parse_keyword(Keyword::DEFAULT); Ok(Statement::Execute { immediate, name, parameters, has_parentheses, into, using, output, default, }) } /// Parse a SQL `PREPARE` statement pub fn parse_prepare(&mut self) -> Result { let name = self.parse_identifier()?; let mut data_types = vec![]; if self.consume_token(&Token::LParen) { data_types = self.parse_comma_separated(Parser::parse_data_type)?; self.expect_token(&Token::RParen)?; } self.expect_keyword_is(Keyword::AS)?; let statement = Box::new(self.parse_statement()?); Ok(Statement::Prepare { name, data_types, statement, }) } /// Parse a SQL `UNLOAD` statement pub fn parse_unload(&mut self) -> Result { self.expect_keyword(Keyword::UNLOAD)?; self.expect_token(&Token::LParen)?; let (query, query_text) = if matches!(self.peek_token_ref().token, Token::SingleQuotedString(_)) { (None, Some(self.parse_literal_string()?)) } else { (Some(self.parse_query()?), None) }; self.expect_token(&Token::RParen)?; self.expect_keyword_is(Keyword::TO)?; let to = self.parse_identifier()?; let auth = if self.parse_keyword(Keyword::IAM_ROLE) { Some(self.parse_iam_role_kind()?) } else { None }; let with = self.parse_options(Keyword::WITH)?; let mut options = vec![]; while let Some(opt) = self.maybe_parse(|parser| parser.parse_copy_legacy_option())? { options.push(opt); } Ok(Statement::Unload { query, query_text, to, auth, with, options, }) } fn parse_select_into(&mut self) -> Result { let temporary = self .parse_one_of_keywords(&[Keyword::TEMP, Keyword::TEMPORARY]) .is_some(); let unlogged = self.parse_keyword(Keyword::UNLOGGED); let table = self.parse_keyword(Keyword::TABLE); let name = self.parse_object_name(false)?; Ok(SelectInto { temporary, unlogged, table, name, }) } fn parse_pragma_value(&mut self) -> Result { let v = self.parse_value()?; match &v.value { Value::SingleQuotedString(_) => Ok(v), Value::DoubleQuotedString(_) => Ok(v), Value::Number(_, _) => Ok(v), Value::Placeholder(_) => Ok(v), _ => { self.prev_token(); self.expected_ref("number or string or ? placeholder", self.peek_token_ref()) } } } /// PRAGMA [schema-name '.'] pragma-name [('=' pragma-value) | '(' pragma-value ')'] pub fn parse_pragma(&mut self) -> Result { let name = self.parse_object_name(false)?; if self.consume_token(&Token::LParen) { let value = self.parse_pragma_value()?; self.expect_token(&Token::RParen)?; Ok(Statement::Pragma { name, value: Some(value), is_eq: false, }) } else if self.consume_token(&Token::Eq) { Ok(Statement::Pragma { name, value: Some(self.parse_pragma_value()?), is_eq: true, }) } else { Ok(Statement::Pragma { name, value: None, is_eq: false, }) } } /// `INSTALL [extension_name]` pub fn parse_install(&mut self) -> Result { let extension_name = self.parse_identifier()?; Ok(Statement::Install { extension_name }) } /// Parse a SQL LOAD statement pub fn parse_load(&mut self) -> Result { if self.dialect.supports_load_extension() { let extension_name = self.parse_identifier()?; Ok(Statement::Load { extension_name }) } else if self.parse_keyword(Keyword::DATA) && self.dialect.supports_load_data() { let local = self.parse_one_of_keywords(&[Keyword::LOCAL]).is_some(); self.expect_keyword_is(Keyword::INPATH)?; let inpath = self.parse_literal_string()?; let overwrite = self.parse_one_of_keywords(&[Keyword::OVERWRITE]).is_some(); self.expect_keyword_is(Keyword::INTO)?; self.expect_keyword_is(Keyword::TABLE)?; let table_name = self.parse_object_name(false)?; let partitioned = self.parse_insert_partition()?; let table_format = self.parse_load_data_table_format()?; Ok(Statement::LoadData { local, inpath, overwrite, table_name, partitioned, table_format, }) } else { self.expected_ref( "`DATA` or an extension name after `LOAD`", self.peek_token_ref(), ) } } /// ClickHouse: /// ```sql /// OPTIMIZE TABLE [db.]name [ON CLUSTER cluster] [PARTITION partition | PARTITION ID 'partition_id'] [FINAL] [DEDUPLICATE [BY expression]] /// ``` /// [ClickHouse](https://clickhouse.com/docs/en/sql-reference/statements/optimize) /// /// Databricks: /// ```sql /// OPTIMIZE table_name [WHERE predicate] [ZORDER BY (col_name1 [, ...])] /// ``` /// [Databricks](https://docs.databricks.com/en/sql/language-manual/delta-optimize.html) pub fn parse_optimize_table(&mut self) -> Result { let has_table_keyword = self.parse_keyword(Keyword::TABLE); let name = self.parse_object_name(false)?; // ClickHouse-specific options let on_cluster = self.parse_optional_on_cluster()?; let partition = if self.parse_keyword(Keyword::PARTITION) { if self.parse_keyword(Keyword::ID) { Some(Partition::Identifier(self.parse_identifier()?)) } else { Some(Partition::Expr(self.parse_expr()?)) } } else { None }; let include_final = self.parse_keyword(Keyword::FINAL); let deduplicate = if self.parse_keyword(Keyword::DEDUPLICATE) { if self.parse_keyword(Keyword::BY) { Some(Deduplicate::ByExpression(self.parse_expr()?)) } else { Some(Deduplicate::All) } } else { None }; // Databricks-specific options let predicate = if self.parse_keyword(Keyword::WHERE) { Some(self.parse_expr()?) } else { None }; let zorder = if self.parse_keywords(&[Keyword::ZORDER, Keyword::BY]) { self.expect_token(&Token::LParen)?; let columns = self.parse_comma_separated(|p| p.parse_expr())?; self.expect_token(&Token::RParen)?; Some(columns) } else { None }; Ok(Statement::OptimizeTable { name, has_table_keyword, on_cluster, partition, include_final, deduplicate, predicate, zorder, }) } /// ```sql /// CREATE [ { TEMPORARY | TEMP } ] SEQUENCE [ IF NOT EXISTS ] /// ``` /// /// See [Postgres docs](https://www.postgresql.org/docs/current/sql-createsequence.html) for more details. pub fn parse_create_sequence(&mut self, temporary: bool) -> Result { //[ IF NOT EXISTS ] let if_not_exists = self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]); //name let name = self.parse_object_name(false)?; //[ AS data_type ] let mut data_type: Option = None; if self.parse_keywords(&[Keyword::AS]) { data_type = Some(self.parse_data_type()?) } let sequence_options = self.parse_create_sequence_options()?; // [ OWNED BY { table_name.column_name | NONE } ] let owned_by = if self.parse_keywords(&[Keyword::OWNED, Keyword::BY]) { if self.parse_keywords(&[Keyword::NONE]) { Some(ObjectName::from(vec![Ident::new("NONE")])) } else { Some(self.parse_object_name(false)?) } } else { None }; Ok(Statement::CreateSequence { temporary, if_not_exists, name, data_type, sequence_options, owned_by, }) } fn parse_create_sequence_options(&mut self) -> Result, ParserError> { let mut sequence_options = vec![]; //[ INCREMENT [ BY ] increment ] if self.parse_keywords(&[Keyword::INCREMENT]) { if self.parse_keywords(&[Keyword::BY]) { sequence_options.push(SequenceOptions::IncrementBy(self.parse_number()?, true)); } else { sequence_options.push(SequenceOptions::IncrementBy(self.parse_number()?, false)); } } //[ MINVALUE minvalue | NO MINVALUE ] if self.parse_keyword(Keyword::MINVALUE) { sequence_options.push(SequenceOptions::MinValue(Some(self.parse_number()?))); } else if self.parse_keywords(&[Keyword::NO, Keyword::MINVALUE]) { sequence_options.push(SequenceOptions::MinValue(None)); } //[ MAXVALUE maxvalue | NO MAXVALUE ] if self.parse_keywords(&[Keyword::MAXVALUE]) { sequence_options.push(SequenceOptions::MaxValue(Some(self.parse_number()?))); } else if self.parse_keywords(&[Keyword::NO, Keyword::MAXVALUE]) { sequence_options.push(SequenceOptions::MaxValue(None)); } //[ START [ WITH ] start ] if self.parse_keywords(&[Keyword::START]) { if self.parse_keywords(&[Keyword::WITH]) { sequence_options.push(SequenceOptions::StartWith(self.parse_number()?, true)); } else { sequence_options.push(SequenceOptions::StartWith(self.parse_number()?, false)); } } //[ CACHE cache ] if self.parse_keywords(&[Keyword::CACHE]) { sequence_options.push(SequenceOptions::Cache(self.parse_number()?)); } // [ [ NO ] CYCLE ] if self.parse_keywords(&[Keyword::NO, Keyword::CYCLE]) { sequence_options.push(SequenceOptions::Cycle(true)); } else if self.parse_keywords(&[Keyword::CYCLE]) { sequence_options.push(SequenceOptions::Cycle(false)); } Ok(sequence_options) } /// Parse a `CREATE SERVER` statement. /// /// See [Statement::CreateServer] pub fn parse_pg_create_server(&mut self) -> Result { let ine = self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]); let name = self.parse_object_name(false)?; let server_type = if self.parse_keyword(Keyword::TYPE) { Some(self.parse_identifier()?) } else { None }; let version = if self.parse_keyword(Keyword::VERSION) { Some(self.parse_identifier()?) } else { None }; self.expect_keywords(&[Keyword::FOREIGN, Keyword::DATA, Keyword::WRAPPER])?; let foreign_data_wrapper = self.parse_object_name(false)?; let mut options = None; if self.parse_keyword(Keyword::OPTIONS) { self.expect_token(&Token::LParen)?; options = Some(self.parse_comma_separated(|p| { let key = p.parse_identifier()?; let value = p.parse_identifier()?; Ok(CreateServerOption { key, value }) })?); self.expect_token(&Token::RParen)?; } Ok(Statement::CreateServer(CreateServerStatement { name, if_not_exists: ine, server_type, version, foreign_data_wrapper, options, })) } /// The index of the first unprocessed token. pub fn index(&self) -> usize { self.index } /// Parse a named window definition. pub fn parse_named_window(&mut self) -> Result { let ident = self.parse_identifier()?; self.expect_keyword_is(Keyword::AS)?; let window_expr = if self.consume_token(&Token::LParen) { NamedWindowExpr::WindowSpec(self.parse_window_spec()?) } else if self.dialect.supports_window_clause_named_window_reference() { NamedWindowExpr::NamedWindow(self.parse_identifier()?) } else { return self.expected_ref("(", self.peek_token_ref()); }; Ok(NamedWindowDefinition(ident, window_expr)) } /// Parse `CREATE PROCEDURE` statement. pub fn parse_create_procedure(&mut self, or_alter: bool) -> Result { let name = self.parse_object_name(false)?; let params = self.parse_optional_procedure_parameters()?; let language = if self.parse_keyword(Keyword::LANGUAGE) { Some(self.parse_identifier()?) } else { None }; self.expect_keyword_is(Keyword::AS)?; let body = self.parse_conditional_statements(&[Keyword::END])?; Ok(Statement::CreateProcedure { name, or_alter, params, language, body, }) } /// Parse a window specification. pub fn parse_window_spec(&mut self) -> Result { let window_name = match &self.peek_token_ref().token { Token::Word(word) if word.keyword == Keyword::NoKeyword => { self.parse_optional_ident()? } _ => None, }; let partition_by = if self.parse_keywords(&[Keyword::PARTITION, Keyword::BY]) { self.parse_comma_separated(Parser::parse_expr)? } else { vec![] }; let order_by = if self.parse_keywords(&[Keyword::ORDER, Keyword::BY]) { self.parse_comma_separated(Parser::parse_order_by_expr)? } else { vec![] }; let window_frame = if !self.consume_token(&Token::RParen) { let window_frame = self.parse_window_frame()?; self.expect_token(&Token::RParen)?; Some(window_frame) } else { None }; Ok(WindowSpec { window_name, partition_by, order_by, window_frame, }) } /// Parse `CREATE TYPE` statement. pub fn parse_create_type(&mut self) -> Result { let name = self.parse_object_name(false)?; // Check if we have AS keyword let has_as = self.parse_keyword(Keyword::AS); if !has_as { // Two cases: CREATE TYPE name; or CREATE TYPE name (options); if self.consume_token(&Token::LParen) { // CREATE TYPE name (options) - SQL definition without AS let options = self.parse_create_type_sql_definition_options()?; self.expect_token(&Token::RParen)?; return Ok(Statement::CreateType { name, representation: Some(UserDefinedTypeRepresentation::SqlDefinition { options }), }); } // CREATE TYPE name; - no representation return Ok(Statement::CreateType { name, representation: None, }); } // We have AS keyword if self.parse_keyword(Keyword::ENUM) { // CREATE TYPE name AS ENUM (labels) self.parse_create_type_enum(name) } else if self.parse_keyword(Keyword::RANGE) { // CREATE TYPE name AS RANGE (options) self.parse_create_type_range(name) } else if self.consume_token(&Token::LParen) { // CREATE TYPE name AS (attributes) - Composite self.parse_create_type_composite(name) } else { self.expected_ref("ENUM, RANGE, or '(' after AS", self.peek_token_ref()) } } /// Parse remainder of `CREATE TYPE AS (attributes)` statement (composite type) /// /// See [PostgreSQL](https://www.postgresql.org/docs/current/sql-createtype.html) fn parse_create_type_composite(&mut self, name: ObjectName) -> Result { if self.consume_token(&Token::RParen) { // Empty composite type return Ok(Statement::CreateType { name, representation: Some(UserDefinedTypeRepresentation::Composite { attributes: vec![], }), }); } let mut attributes = vec![]; loop { let attr_name = self.parse_identifier()?; let attr_data_type = self.parse_data_type()?; let attr_collation = if self.parse_keyword(Keyword::COLLATE) { Some(self.parse_object_name(false)?) } else { None }; attributes.push(UserDefinedTypeCompositeAttributeDef { name: attr_name, data_type: attr_data_type, collation: attr_collation, }); if !self.consume_token(&Token::Comma) { break; } } self.expect_token(&Token::RParen)?; Ok(Statement::CreateType { name, representation: Some(UserDefinedTypeRepresentation::Composite { attributes }), }) } /// Parse remainder of `CREATE TYPE AS ENUM` statement (see [Statement::CreateType] and [Self::parse_create_type]) /// /// See [PostgreSQL](https://www.postgresql.org/docs/current/sql-createtype.html) pub fn parse_create_type_enum(&mut self, name: ObjectName) -> Result { self.expect_token(&Token::LParen)?; let labels = self.parse_comma_separated0(|p| p.parse_identifier(), Token::RParen)?; self.expect_token(&Token::RParen)?; Ok(Statement::CreateType { name, representation: Some(UserDefinedTypeRepresentation::Enum { labels }), }) } /// Parse remainder of `CREATE TYPE AS RANGE` statement /// /// See [PostgreSQL](https://www.postgresql.org/docs/current/sql-createtype.html) fn parse_create_type_range(&mut self, name: ObjectName) -> Result { self.expect_token(&Token::LParen)?; let options = self.parse_comma_separated0(|p| p.parse_range_option(), Token::RParen)?; self.expect_token(&Token::RParen)?; Ok(Statement::CreateType { name, representation: Some(UserDefinedTypeRepresentation::Range { options }), }) } /// Parse a single range option for a `CREATE TYPE AS RANGE` statement fn parse_range_option(&mut self) -> Result { let keyword = self.parse_one_of_keywords(&[ Keyword::SUBTYPE, Keyword::SUBTYPE_OPCLASS, Keyword::COLLATION, Keyword::CANONICAL, Keyword::SUBTYPE_DIFF, Keyword::MULTIRANGE_TYPE_NAME, ]); match keyword { Some(Keyword::SUBTYPE) => { self.expect_token(&Token::Eq)?; let data_type = self.parse_data_type()?; Ok(UserDefinedTypeRangeOption::Subtype(data_type)) } Some(Keyword::SUBTYPE_OPCLASS) => { self.expect_token(&Token::Eq)?; let name = self.parse_object_name(false)?; Ok(UserDefinedTypeRangeOption::SubtypeOpClass(name)) } Some(Keyword::COLLATION) => { self.expect_token(&Token::Eq)?; let name = self.parse_object_name(false)?; Ok(UserDefinedTypeRangeOption::Collation(name)) } Some(Keyword::CANONICAL) => { self.expect_token(&Token::Eq)?; let name = self.parse_object_name(false)?; Ok(UserDefinedTypeRangeOption::Canonical(name)) } Some(Keyword::SUBTYPE_DIFF) => { self.expect_token(&Token::Eq)?; let name = self.parse_object_name(false)?; Ok(UserDefinedTypeRangeOption::SubtypeDiff(name)) } Some(Keyword::MULTIRANGE_TYPE_NAME) => { self.expect_token(&Token::Eq)?; let name = self.parse_object_name(false)?; Ok(UserDefinedTypeRangeOption::MultirangeTypeName(name)) } _ => self.expected_ref("range option keyword", self.peek_token_ref()), } } /// Parse SQL definition options for CREATE TYPE (options) fn parse_create_type_sql_definition_options( &mut self, ) -> Result, ParserError> { self.parse_comma_separated0(|p| p.parse_sql_definition_option(), Token::RParen) } /// Parse a single SQL definition option for CREATE TYPE (options) fn parse_sql_definition_option( &mut self, ) -> Result { let keyword = self.parse_one_of_keywords(&[ Keyword::INPUT, Keyword::OUTPUT, Keyword::RECEIVE, Keyword::SEND, Keyword::TYPMOD_IN, Keyword::TYPMOD_OUT, Keyword::ANALYZE, Keyword::SUBSCRIPT, Keyword::INTERNALLENGTH, Keyword::PASSEDBYVALUE, Keyword::ALIGNMENT, Keyword::STORAGE, Keyword::LIKE, Keyword::CATEGORY, Keyword::PREFERRED, Keyword::DEFAULT, Keyword::ELEMENT, Keyword::DELIMITER, Keyword::COLLATABLE, ]); match keyword { Some(Keyword::INPUT) => { self.expect_token(&Token::Eq)?; let name = self.parse_object_name(false)?; Ok(UserDefinedTypeSqlDefinitionOption::Input(name)) } Some(Keyword::OUTPUT) => { self.expect_token(&Token::Eq)?; let name = self.parse_object_name(false)?; Ok(UserDefinedTypeSqlDefinitionOption::Output(name)) } Some(Keyword::RECEIVE) => { self.expect_token(&Token::Eq)?; let name = self.parse_object_name(false)?; Ok(UserDefinedTypeSqlDefinitionOption::Receive(name)) } Some(Keyword::SEND) => { self.expect_token(&Token::Eq)?; let name = self.parse_object_name(false)?; Ok(UserDefinedTypeSqlDefinitionOption::Send(name)) } Some(Keyword::TYPMOD_IN) => { self.expect_token(&Token::Eq)?; let name = self.parse_object_name(false)?; Ok(UserDefinedTypeSqlDefinitionOption::TypmodIn(name)) } Some(Keyword::TYPMOD_OUT) => { self.expect_token(&Token::Eq)?; let name = self.parse_object_name(false)?; Ok(UserDefinedTypeSqlDefinitionOption::TypmodOut(name)) } Some(Keyword::ANALYZE) => { self.expect_token(&Token::Eq)?; let name = self.parse_object_name(false)?; Ok(UserDefinedTypeSqlDefinitionOption::Analyze(name)) } Some(Keyword::SUBSCRIPT) => { self.expect_token(&Token::Eq)?; let name = self.parse_object_name(false)?; Ok(UserDefinedTypeSqlDefinitionOption::Subscript(name)) } Some(Keyword::INTERNALLENGTH) => { self.expect_token(&Token::Eq)?; if self.parse_keyword(Keyword::VARIABLE) { Ok(UserDefinedTypeSqlDefinitionOption::InternalLength( UserDefinedTypeInternalLength::Variable, )) } else { let value = self.parse_literal_uint()?; Ok(UserDefinedTypeSqlDefinitionOption::InternalLength( UserDefinedTypeInternalLength::Fixed(value), )) } } Some(Keyword::PASSEDBYVALUE) => Ok(UserDefinedTypeSqlDefinitionOption::PassedByValue), Some(Keyword::ALIGNMENT) => { self.expect_token(&Token::Eq)?; let align_keyword = self.parse_one_of_keywords(&[ Keyword::CHAR, Keyword::INT2, Keyword::INT4, Keyword::DOUBLE, ]); match align_keyword { Some(Keyword::CHAR) => Ok(UserDefinedTypeSqlDefinitionOption::Alignment( Alignment::Char, )), Some(Keyword::INT2) => Ok(UserDefinedTypeSqlDefinitionOption::Alignment( Alignment::Int2, )), Some(Keyword::INT4) => Ok(UserDefinedTypeSqlDefinitionOption::Alignment( Alignment::Int4, )), Some(Keyword::DOUBLE) => Ok(UserDefinedTypeSqlDefinitionOption::Alignment( Alignment::Double, )), _ => self.expected_ref( "alignment value (char, int2, int4, or double)", self.peek_token_ref(), ), } } Some(Keyword::STORAGE) => { self.expect_token(&Token::Eq)?; let storage_keyword = self.parse_one_of_keywords(&[ Keyword::PLAIN, Keyword::EXTERNAL, Keyword::EXTENDED, Keyword::MAIN, ]); match storage_keyword { Some(Keyword::PLAIN) => Ok(UserDefinedTypeSqlDefinitionOption::Storage( UserDefinedTypeStorage::Plain, )), Some(Keyword::EXTERNAL) => Ok(UserDefinedTypeSqlDefinitionOption::Storage( UserDefinedTypeStorage::External, )), Some(Keyword::EXTENDED) => Ok(UserDefinedTypeSqlDefinitionOption::Storage( UserDefinedTypeStorage::Extended, )), Some(Keyword::MAIN) => Ok(UserDefinedTypeSqlDefinitionOption::Storage( UserDefinedTypeStorage::Main, )), _ => self.expected_ref( "storage value (plain, external, extended, or main)", self.peek_token_ref(), ), } } Some(Keyword::LIKE) => { self.expect_token(&Token::Eq)?; let name = self.parse_object_name(false)?; Ok(UserDefinedTypeSqlDefinitionOption::Like(name)) } Some(Keyword::CATEGORY) => { self.expect_token(&Token::Eq)?; let category_str = self.parse_literal_string()?; let category_char = category_str.chars().next().ok_or_else(|| { ParserError::ParserError( "CATEGORY value must be a single character".to_string(), ) })?; Ok(UserDefinedTypeSqlDefinitionOption::Category(category_char)) } Some(Keyword::PREFERRED) => { self.expect_token(&Token::Eq)?; let value = self.parse_keyword(Keyword::TRUE) || !self.parse_keyword(Keyword::FALSE); Ok(UserDefinedTypeSqlDefinitionOption::Preferred(value)) } Some(Keyword::DEFAULT) => { self.expect_token(&Token::Eq)?; let expr = self.parse_expr()?; Ok(UserDefinedTypeSqlDefinitionOption::Default(expr)) } Some(Keyword::ELEMENT) => { self.expect_token(&Token::Eq)?; let data_type = self.parse_data_type()?; Ok(UserDefinedTypeSqlDefinitionOption::Element(data_type)) } Some(Keyword::DELIMITER) => { self.expect_token(&Token::Eq)?; let delimiter = self.parse_literal_string()?; Ok(UserDefinedTypeSqlDefinitionOption::Delimiter(delimiter)) } Some(Keyword::COLLATABLE) => { self.expect_token(&Token::Eq)?; let value = self.parse_keyword(Keyword::TRUE) || !self.parse_keyword(Keyword::FALSE); Ok(UserDefinedTypeSqlDefinitionOption::Collatable(value)) } _ => self.expected_ref("SQL definition option keyword", self.peek_token_ref()), } } fn parse_parenthesized_identifiers(&mut self) -> Result, ParserError> { self.expect_token(&Token::LParen)?; let idents = self.parse_comma_separated0(|p| p.parse_identifier(), Token::RParen)?; self.expect_token(&Token::RParen)?; Ok(idents) } fn parse_column_position(&mut self) -> Result, ParserError> { if dialect_of!(self is MySqlDialect | GenericDialect) { if self.parse_keyword(Keyword::FIRST) { Ok(Some(MySQLColumnPosition::First)) } else if self.parse_keyword(Keyword::AFTER) { let ident = self.parse_identifier()?; Ok(Some(MySQLColumnPosition::After(ident))) } else { Ok(None) } } else { Ok(None) } } /// Parse [Statement::Print] fn parse_print(&mut self) -> Result { Ok(Statement::Print(PrintStatement { message: Box::new(self.parse_expr()?), })) } /// Parse [Statement::WaitFor] /// /// See: fn parse_waitfor(&mut self) -> Result { let wait_type = if self.parse_keyword(Keyword::DELAY) { WaitForType::Delay } else if self.parse_keyword(Keyword::TIME) { WaitForType::Time } else { return self.expected_ref("DELAY or TIME", self.peek_token_ref()); }; let expr = self.parse_expr()?; Ok(Statement::WaitFor(WaitForStatement { wait_type, expr })) } /// Parse [Statement::Return] fn parse_return(&mut self) -> Result { match self.maybe_parse(|p| p.parse_expr())? { Some(expr) => Ok(Statement::Return(ReturnStatement { value: Some(ReturnStatementValue::Expr(expr)), })), None => Ok(Statement::Return(ReturnStatement { value: None })), } } /// /// Parse a `EXPORT DATA` statement. /// /// See [Statement::ExportData] fn parse_export_data(&mut self) -> Result { self.expect_keywords(&[Keyword::EXPORT, Keyword::DATA])?; let connection = if self.parse_keywords(&[Keyword::WITH, Keyword::CONNECTION]) { Some(self.parse_object_name(false)?) } else { None }; self.expect_keyword(Keyword::OPTIONS)?; self.expect_token(&Token::LParen)?; let options = self.parse_comma_separated(|p| p.parse_sql_option())?; self.expect_token(&Token::RParen)?; self.expect_keyword(Keyword::AS)?; let query = self.parse_query()?; Ok(Statement::ExportData(ExportData { options, query, connection, })) } fn parse_vacuum(&mut self) -> Result { self.expect_keyword(Keyword::VACUUM)?; let full = self.parse_keyword(Keyword::FULL); let sort_only = self.parse_keywords(&[Keyword::SORT, Keyword::ONLY]); let delete_only = self.parse_keywords(&[Keyword::DELETE, Keyword::ONLY]); let reindex = self.parse_keyword(Keyword::REINDEX); let recluster = self.parse_keyword(Keyword::RECLUSTER); let (table_name, threshold, boost) = match self.maybe_parse(|p| p.parse_object_name(false))? { Some(table_name) => { let threshold = if self.parse_keyword(Keyword::TO) { let value = self.parse_value()?; self.expect_keyword(Keyword::PERCENT)?; Some(value) } else { None }; let boost = self.parse_keyword(Keyword::BOOST); (Some(table_name), threshold, boost) } _ => (None, None, false), }; Ok(Statement::Vacuum(VacuumStatement { full, sort_only, delete_only, reindex, recluster, table_name, threshold, boost, })) } /// Consume the parser and return its underlying token buffer pub fn into_tokens(self) -> Vec { self.tokens } /// Returns true if the next keyword indicates a sub query, i.e. SELECT or WITH fn peek_sub_query(&mut self) -> bool { self.peek_one_of_keywords(&[Keyword::SELECT, Keyword::WITH]) .is_some() } pub(crate) fn parse_show_stmt_options(&mut self) -> Result { let show_in; let mut filter_position = None; if self.dialect.supports_show_like_before_in() { if let Some(filter) = self.parse_show_statement_filter()? { filter_position = Some(ShowStatementFilterPosition::Infix(filter)); } show_in = self.maybe_parse_show_stmt_in()?; } else { show_in = self.maybe_parse_show_stmt_in()?; if let Some(filter) = self.parse_show_statement_filter()? { filter_position = Some(ShowStatementFilterPosition::Suffix(filter)); } } let starts_with = self.maybe_parse_show_stmt_starts_with()?; let limit = self.maybe_parse_show_stmt_limit()?; let from = self.maybe_parse_show_stmt_from()?; Ok(ShowStatementOptions { filter_position, show_in, starts_with, limit, limit_from: from, }) } fn maybe_parse_show_stmt_in(&mut self) -> Result, ParserError> { let clause = match self.parse_one_of_keywords(&[Keyword::FROM, Keyword::IN]) { Some(Keyword::FROM) => ShowStatementInClause::FROM, Some(Keyword::IN) => ShowStatementInClause::IN, None => return Ok(None), _ => return self.expected_ref("FROM or IN", self.peek_token_ref()), }; let (parent_type, parent_name) = match self.parse_one_of_keywords(&[ Keyword::ACCOUNT, Keyword::DATABASE, Keyword::SCHEMA, Keyword::TABLE, Keyword::VIEW, ]) { // If we see these next keywords it means we don't have a parent name Some(Keyword::DATABASE) if self.peek_keywords(&[Keyword::STARTS, Keyword::WITH]) | self.peek_keyword(Keyword::LIMIT) => { (Some(ShowStatementInParentType::Database), None) } Some(Keyword::SCHEMA) if self.peek_keywords(&[Keyword::STARTS, Keyword::WITH]) | self.peek_keyword(Keyword::LIMIT) => { (Some(ShowStatementInParentType::Schema), None) } Some(parent_kw) => { // The parent name here is still optional, for example: // SHOW TABLES IN ACCOUNT, so parsing the object name // may fail because the statement ends. let parent_name = self.maybe_parse(|p| p.parse_object_name(false))?; match parent_kw { Keyword::ACCOUNT => (Some(ShowStatementInParentType::Account), parent_name), Keyword::DATABASE => (Some(ShowStatementInParentType::Database), parent_name), Keyword::SCHEMA => (Some(ShowStatementInParentType::Schema), parent_name), Keyword::TABLE => (Some(ShowStatementInParentType::Table), parent_name), Keyword::VIEW => (Some(ShowStatementInParentType::View), parent_name), _ => { return self.expected_ref( "one of ACCOUNT, DATABASE, SCHEMA, TABLE or VIEW", self.peek_token_ref(), ) } } } None => { // Parsing MySQL style FROM tbl_name FROM db_name // which is equivalent to FROM tbl_name.db_name let mut parent_name = self.parse_object_name(false)?; if self .parse_one_of_keywords(&[Keyword::FROM, Keyword::IN]) .is_some() { parent_name .0 .insert(0, ObjectNamePart::Identifier(self.parse_identifier()?)); } (None, Some(parent_name)) } }; Ok(Some(ShowStatementIn { clause, parent_type, parent_name, })) } fn maybe_parse_show_stmt_starts_with(&mut self) -> Result, ParserError> { if self.parse_keywords(&[Keyword::STARTS, Keyword::WITH]) { Ok(Some(self.parse_value()?)) } else { Ok(None) } } fn maybe_parse_show_stmt_limit(&mut self) -> Result, ParserError> { if self.parse_keyword(Keyword::LIMIT) { Ok(self.parse_limit()?) } else { Ok(None) } } fn maybe_parse_show_stmt_from(&mut self) -> Result, ParserError> { if self.parse_keyword(Keyword::FROM) { Ok(Some(self.parse_value()?)) } else { Ok(None) } } pub(crate) fn in_column_definition_state(&self) -> bool { matches!(self.state, ColumnDefinition) } /// Parses options provided in key-value format. /// /// * `parenthesized` - true if the options are enclosed in parenthesis /// * `end_words` - a list of keywords that any of them indicates the end of the options section pub(crate) fn parse_key_value_options( &mut self, parenthesized: bool, end_words: &[Keyword], ) -> Result { let mut options: Vec = Vec::new(); let mut delimiter = KeyValueOptionsDelimiter::Space; if parenthesized { self.expect_token(&Token::LParen)?; } loop { match self.next_token().token { Token::RParen => { if parenthesized { break; } else { return self.expected_ref(" another option or EOF", self.peek_token_ref()); } } Token::EOF | Token::SemiColon => break, Token::Comma => { delimiter = KeyValueOptionsDelimiter::Comma; continue; } Token::Word(w) if !end_words.contains(&w.keyword) => { options.push(self.parse_key_value_option(&w)?) } Token::Word(w) if end_words.contains(&w.keyword) => { self.prev_token(); break; } _ => { return self.expected_ref( "another option, EOF, SemiColon, Comma or ')'", self.peek_token_ref(), ) } }; } Ok(KeyValueOptions { delimiter, options }) } /// Parses a `KEY = VALUE` construct based on the specified key pub(crate) fn parse_key_value_option( &mut self, key: &Word, ) -> Result { self.expect_token(&Token::Eq)?; let peeked_token = self.peek_token(); match peeked_token.token { Token::SingleQuotedString(_) => Ok(KeyValueOption { option_name: key.value.clone(), option_value: KeyValueOptionKind::Single(self.parse_value()?), }), Token::Word(word) if word.keyword == Keyword::TRUE || word.keyword == Keyword::FALSE => { Ok(KeyValueOption { option_name: key.value.clone(), option_value: KeyValueOptionKind::Single(self.parse_value()?), }) } Token::Number(..) => Ok(KeyValueOption { option_name: key.value.clone(), option_value: KeyValueOptionKind::Single(self.parse_value()?), }), Token::Word(word) => { self.next_token(); Ok(KeyValueOption { option_name: key.value.clone(), option_value: KeyValueOptionKind::Single( Value::Placeholder(word.value.clone()).with_span(peeked_token.span), ), }) } Token::LParen => { // Can be a list of values or a list of key value properties. // Try to parse a list of values and if that fails, try to parse // a list of key-value properties. match self.maybe_parse(|parser| { parser.expect_token(&Token::LParen)?; let values = parser.parse_comma_separated0(|p| p.parse_value(), Token::RParen); parser.expect_token(&Token::RParen)?; values })? { Some(values) => Ok(KeyValueOption { option_name: key.value.clone(), option_value: KeyValueOptionKind::Multi(values), }), None => Ok(KeyValueOption { option_name: key.value.clone(), option_value: KeyValueOptionKind::KeyValueOptions(Box::new( self.parse_key_value_options(true, &[])?, )), }), } } _ => self.expected_ref("expected option value", self.peek_token_ref()), } } /// Parses a RESET statement fn parse_reset(&mut self) -> Result { if self.parse_keyword(Keyword::ALL) { return Ok(ResetStatement { reset: Reset::ALL }); } let obj = self.parse_object_name(false)?; Ok(ResetStatement { reset: Reset::ConfigurationParameter(obj), }) } } fn maybe_prefixed_expr(expr: Expr, prefix: Option) -> Expr { if let Some(prefix) = prefix { Expr::Prefixed { prefix, value: Box::new(expr), } } else { expr } } impl Word { /// Convert a reference to this word into an [`Ident`] by cloning the value. /// /// Use this method when you need to keep the original `Word` around. /// If you can consume the `Word`, prefer [`into_ident`](Self::into_ident) instead /// to avoid cloning. pub fn to_ident(&self, span: Span) -> Ident { Ident { value: self.value.clone(), quote_style: self.quote_style, span, } } /// Convert this word into an [`Ident`] identifier, consuming the `Word`. /// /// This avoids cloning the string value. If you need to keep the original /// `Word`, use [`to_ident`](Self::to_ident) instead. pub fn into_ident(self, span: Span) -> Ident { Ident { value: self.value, quote_style: self.quote_style, span, } } } #[cfg(test)] mod tests { use crate::test_utils::{all_dialects, TestedDialects}; use super::*; #[test] fn test_prev_index() { let sql = "SELECT version"; all_dialects().run_parser_method(sql, |parser| { assert_eq!(parser.peek_token(), Token::make_keyword("SELECT")); assert_eq!(parser.next_token(), Token::make_keyword("SELECT")); parser.prev_token(); assert_eq!(parser.next_token(), Token::make_keyword("SELECT")); assert_eq!(parser.next_token(), Token::make_word("version", None)); parser.prev_token(); assert_eq!(parser.peek_token(), Token::make_word("version", None)); assert_eq!(parser.next_token(), Token::make_word("version", None)); assert_eq!(parser.peek_token(), Token::EOF); parser.prev_token(); assert_eq!(parser.next_token(), Token::make_word("version", None)); assert_eq!(parser.next_token(), Token::EOF); assert_eq!(parser.next_token(), Token::EOF); parser.prev_token(); }); } #[test] fn test_peek_tokens() { all_dialects().run_parser_method("SELECT foo AS bar FROM baz", |parser| { assert!(matches!( parser.peek_tokens(), [Token::Word(Word { keyword: Keyword::SELECT, .. })] )); assert!(matches!( parser.peek_tokens(), [ Token::Word(Word { keyword: Keyword::SELECT, .. }), Token::Word(_), Token::Word(Word { keyword: Keyword::AS, .. }), ] )); for _ in 0..4 { parser.next_token(); } assert!(matches!( parser.peek_tokens(), [ Token::Word(Word { keyword: Keyword::FROM, .. }), Token::Word(_), Token::EOF, Token::EOF, ] )) }) } #[cfg(test)] mod test_parse_data_type { use crate::ast::{ CharLengthUnits, CharacterLength, DataType, ExactNumberInfo, ObjectName, TimezoneInfo, }; use crate::dialect::{AnsiDialect, GenericDialect, PostgreSqlDialect}; use crate::test_utils::TestedDialects; macro_rules! test_parse_data_type { ($dialect:expr, $input:expr, $expected_type:expr $(,)?) => {{ $dialect.run_parser_method(&*$input, |parser| { let data_type = parser.parse_data_type().unwrap(); assert_eq!($expected_type, data_type); assert_eq!($input.to_string(), data_type.to_string()); }); }}; } #[test] fn test_ansii_character_string_types() { // Character string types: let dialect = TestedDialects::new(vec![Box::new(GenericDialect {}), Box::new(AnsiDialect {})]); test_parse_data_type!(dialect, "CHARACTER", DataType::Character(None)); test_parse_data_type!( dialect, "CHARACTER(20)", DataType::Character(Some(CharacterLength::IntegerLength { length: 20, unit: None })) ); test_parse_data_type!( dialect, "CHARACTER(20 CHARACTERS)", DataType::Character(Some(CharacterLength::IntegerLength { length: 20, unit: Some(CharLengthUnits::Characters) })) ); test_parse_data_type!( dialect, "CHARACTER(20 OCTETS)", DataType::Character(Some(CharacterLength::IntegerLength { length: 20, unit: Some(CharLengthUnits::Octets) })) ); test_parse_data_type!(dialect, "CHAR", DataType::Char(None)); test_parse_data_type!( dialect, "CHAR(20)", DataType::Char(Some(CharacterLength::IntegerLength { length: 20, unit: None })) ); test_parse_data_type!( dialect, "CHAR(20 CHARACTERS)", DataType::Char(Some(CharacterLength::IntegerLength { length: 20, unit: Some(CharLengthUnits::Characters) })) ); test_parse_data_type!( dialect, "CHAR(20 OCTETS)", DataType::Char(Some(CharacterLength::IntegerLength { length: 20, unit: Some(CharLengthUnits::Octets) })) ); test_parse_data_type!( dialect, "CHARACTER VARYING(20)", DataType::CharacterVarying(Some(CharacterLength::IntegerLength { length: 20, unit: None })) ); test_parse_data_type!( dialect, "CHARACTER VARYING(20 CHARACTERS)", DataType::CharacterVarying(Some(CharacterLength::IntegerLength { length: 20, unit: Some(CharLengthUnits::Characters) })) ); test_parse_data_type!( dialect, "CHARACTER VARYING(20 OCTETS)", DataType::CharacterVarying(Some(CharacterLength::IntegerLength { length: 20, unit: Some(CharLengthUnits::Octets) })) ); test_parse_data_type!( dialect, "CHAR VARYING(20)", DataType::CharVarying(Some(CharacterLength::IntegerLength { length: 20, unit: None })) ); test_parse_data_type!( dialect, "CHAR VARYING(20 CHARACTERS)", DataType::CharVarying(Some(CharacterLength::IntegerLength { length: 20, unit: Some(CharLengthUnits::Characters) })) ); test_parse_data_type!( dialect, "CHAR VARYING(20 OCTETS)", DataType::CharVarying(Some(CharacterLength::IntegerLength { length: 20, unit: Some(CharLengthUnits::Octets) })) ); test_parse_data_type!( dialect, "VARCHAR(20)", DataType::Varchar(Some(CharacterLength::IntegerLength { length: 20, unit: None })) ); } #[test] fn test_ansii_character_large_object_types() { // Character large object types: let dialect = TestedDialects::new(vec![Box::new(GenericDialect {}), Box::new(AnsiDialect {})]); test_parse_data_type!( dialect, "CHARACTER LARGE OBJECT", DataType::CharacterLargeObject(None) ); test_parse_data_type!( dialect, "CHARACTER LARGE OBJECT(20)", DataType::CharacterLargeObject(Some(20)) ); test_parse_data_type!( dialect, "CHAR LARGE OBJECT", DataType::CharLargeObject(None) ); test_parse_data_type!( dialect, "CHAR LARGE OBJECT(20)", DataType::CharLargeObject(Some(20)) ); test_parse_data_type!(dialect, "CLOB", DataType::Clob(None)); test_parse_data_type!(dialect, "CLOB(20)", DataType::Clob(Some(20))); } #[test] fn test_parse_custom_types() { let dialect = TestedDialects::new(vec![Box::new(GenericDialect {}), Box::new(AnsiDialect {})]); test_parse_data_type!( dialect, "GEOMETRY", DataType::Custom(ObjectName::from(vec!["GEOMETRY".into()]), vec![]) ); test_parse_data_type!( dialect, "GEOMETRY(POINT)", DataType::Custom( ObjectName::from(vec!["GEOMETRY".into()]), vec!["POINT".to_string()] ) ); test_parse_data_type!( dialect, "GEOMETRY(POINT, 4326)", DataType::Custom( ObjectName::from(vec!["GEOMETRY".into()]), vec!["POINT".to_string(), "4326".to_string()] ) ); } #[test] fn test_ansii_exact_numeric_types() { // Exact numeric types: let dialect = TestedDialects::new(vec![ Box::new(GenericDialect {}), Box::new(AnsiDialect {}), Box::new(PostgreSqlDialect {}), ]); test_parse_data_type!(dialect, "NUMERIC", DataType::Numeric(ExactNumberInfo::None)); test_parse_data_type!( dialect, "NUMERIC(2)", DataType::Numeric(ExactNumberInfo::Precision(2)) ); test_parse_data_type!( dialect, "NUMERIC(2,10)", DataType::Numeric(ExactNumberInfo::PrecisionAndScale(2, 10)) ); test_parse_data_type!(dialect, "DECIMAL", DataType::Decimal(ExactNumberInfo::None)); test_parse_data_type!( dialect, "DECIMAL(2)", DataType::Decimal(ExactNumberInfo::Precision(2)) ); test_parse_data_type!( dialect, "DECIMAL(2,10)", DataType::Decimal(ExactNumberInfo::PrecisionAndScale(2, 10)) ); test_parse_data_type!(dialect, "DEC", DataType::Dec(ExactNumberInfo::None)); test_parse_data_type!( dialect, "DEC(2)", DataType::Dec(ExactNumberInfo::Precision(2)) ); test_parse_data_type!( dialect, "DEC(2,10)", DataType::Dec(ExactNumberInfo::PrecisionAndScale(2, 10)) ); // Test negative scale values. test_parse_data_type!( dialect, "NUMERIC(10,-2)", DataType::Numeric(ExactNumberInfo::PrecisionAndScale(10, -2)) ); test_parse_data_type!( dialect, "DECIMAL(1000,-10)", DataType::Decimal(ExactNumberInfo::PrecisionAndScale(1000, -10)) ); test_parse_data_type!( dialect, "DEC(5,-1000)", DataType::Dec(ExactNumberInfo::PrecisionAndScale(5, -1000)) ); test_parse_data_type!( dialect, "NUMERIC(10,-5)", DataType::Numeric(ExactNumberInfo::PrecisionAndScale(10, -5)) ); test_parse_data_type!( dialect, "DECIMAL(20,-10)", DataType::Decimal(ExactNumberInfo::PrecisionAndScale(20, -10)) ); test_parse_data_type!( dialect, "DEC(5,-2)", DataType::Dec(ExactNumberInfo::PrecisionAndScale(5, -2)) ); dialect.run_parser_method("NUMERIC(10,+5)", |parser| { let data_type = parser.parse_data_type().unwrap(); assert_eq!( DataType::Numeric(ExactNumberInfo::PrecisionAndScale(10, 5)), data_type ); // Note: Explicit '+' sign is not preserved in output, which is correct assert_eq!("NUMERIC(10,5)", data_type.to_string()); }); } #[test] fn test_ansii_date_type() { // Datetime types: let dialect = TestedDialects::new(vec![Box::new(GenericDialect {}), Box::new(AnsiDialect {})]); test_parse_data_type!(dialect, "DATE", DataType::Date); test_parse_data_type!(dialect, "TIME", DataType::Time(None, TimezoneInfo::None)); test_parse_data_type!( dialect, "TIME(6)", DataType::Time(Some(6), TimezoneInfo::None) ); test_parse_data_type!( dialect, "TIME WITH TIME ZONE", DataType::Time(None, TimezoneInfo::WithTimeZone) ); test_parse_data_type!( dialect, "TIME(6) WITH TIME ZONE", DataType::Time(Some(6), TimezoneInfo::WithTimeZone) ); test_parse_data_type!( dialect, "TIME WITHOUT TIME ZONE", DataType::Time(None, TimezoneInfo::WithoutTimeZone) ); test_parse_data_type!( dialect, "TIME(6) WITHOUT TIME ZONE", DataType::Time(Some(6), TimezoneInfo::WithoutTimeZone) ); test_parse_data_type!( dialect, "TIMESTAMP", DataType::Timestamp(None, TimezoneInfo::None) ); test_parse_data_type!( dialect, "TIMESTAMP(22)", DataType::Timestamp(Some(22), TimezoneInfo::None) ); test_parse_data_type!( dialect, "TIMESTAMP(22) WITH TIME ZONE", DataType::Timestamp(Some(22), TimezoneInfo::WithTimeZone) ); test_parse_data_type!( dialect, "TIMESTAMP(33) WITHOUT TIME ZONE", DataType::Timestamp(Some(33), TimezoneInfo::WithoutTimeZone) ); } } #[test] fn test_parse_schema_name() { // The expected name should be identical as the input name, that's why I don't receive both macro_rules! test_parse_schema_name { ($input:expr, $expected_name:expr $(,)?) => {{ all_dialects().run_parser_method(&*$input, |parser| { let schema_name = parser.parse_schema_name().unwrap(); // Validate that the structure is the same as expected assert_eq!(schema_name, $expected_name); // Validate that the input and the expected structure serialization are the same assert_eq!(schema_name.to_string(), $input.to_string()); }); }}; } let dummy_name = ObjectName::from(vec![Ident::new("dummy_name")]); let dummy_authorization = Ident::new("dummy_authorization"); test_parse_schema_name!( format!("{dummy_name}"), SchemaName::Simple(dummy_name.clone()) ); test_parse_schema_name!( format!("AUTHORIZATION {dummy_authorization}"), SchemaName::UnnamedAuthorization(dummy_authorization.clone()), ); test_parse_schema_name!( format!("{dummy_name} AUTHORIZATION {dummy_authorization}"), SchemaName::NamedAuthorization(dummy_name.clone(), dummy_authorization.clone()), ); } #[test] fn mysql_parse_index_table_constraint() { macro_rules! test_parse_table_constraint { ($dialect:expr, $input:expr, $expected:expr $(,)?) => {{ $dialect.run_parser_method(&*$input, |parser| { let constraint = parser.parse_optional_table_constraint().unwrap().unwrap(); // Validate that the structure is the same as expected assert_eq!(constraint, $expected); // Validate that the input and the expected structure serialization are the same assert_eq!(constraint.to_string(), $input.to_string()); }); }}; } fn mk_expected_col(name: &str) -> IndexColumn { IndexColumn { column: OrderByExpr { expr: Expr::Identifier(name.into()), options: OrderByOptions { asc: None, nulls_first: None, }, with_fill: None, }, operator_class: None, } } let dialect = TestedDialects::new(vec![Box::new(GenericDialect {}), Box::new(MySqlDialect {})]); test_parse_table_constraint!( dialect, "INDEX (c1)", IndexConstraint { display_as_key: false, name: None, index_type: None, columns: vec![mk_expected_col("c1")], index_options: vec![], } .into() ); test_parse_table_constraint!( dialect, "KEY (c1)", IndexConstraint { display_as_key: true, name: None, index_type: None, columns: vec![mk_expected_col("c1")], index_options: vec![], } .into() ); test_parse_table_constraint!( dialect, "INDEX 'index' (c1, c2)", TableConstraint::Index(IndexConstraint { display_as_key: false, name: Some(Ident::with_quote('\'', "index")), index_type: None, columns: vec![mk_expected_col("c1"), mk_expected_col("c2")], index_options: vec![], }) ); test_parse_table_constraint!( dialect, "INDEX USING BTREE (c1)", IndexConstraint { display_as_key: false, name: None, index_type: Some(IndexType::BTree), columns: vec![mk_expected_col("c1")], index_options: vec![], } .into() ); test_parse_table_constraint!( dialect, "INDEX USING HASH (c1)", IndexConstraint { display_as_key: false, name: None, index_type: Some(IndexType::Hash), columns: vec![mk_expected_col("c1")], index_options: vec![], } .into() ); test_parse_table_constraint!( dialect, "INDEX idx_name USING BTREE (c1)", IndexConstraint { display_as_key: false, name: Some(Ident::new("idx_name")), index_type: Some(IndexType::BTree), columns: vec![mk_expected_col("c1")], index_options: vec![], } .into() ); test_parse_table_constraint!( dialect, "INDEX idx_name USING HASH (c1)", IndexConstraint { display_as_key: false, name: Some(Ident::new("idx_name")), index_type: Some(IndexType::Hash), columns: vec![mk_expected_col("c1")], index_options: vec![], } .into() ); } #[test] fn test_tokenizer_error_loc() { let sql = "foo '"; let ast = Parser::parse_sql(&GenericDialect, sql); assert_eq!( ast, Err(ParserError::TokenizerError( "Unterminated string literal at Line: 1, Column: 5".to_string() )) ); } #[test] fn test_parser_error_loc() { let sql = "SELECT this is a syntax error"; let ast = Parser::parse_sql(&GenericDialect, sql); assert_eq!( ast, Err(ParserError::ParserError( "Expected: [NOT] NULL | TRUE | FALSE | DISTINCT | [form] NORMALIZED FROM after IS, found: a at Line: 1, Column: 16" .to_string() )) ); } #[test] fn test_nested_explain_error() { let sql = "EXPLAIN EXPLAIN SELECT 1"; let ast = Parser::parse_sql(&GenericDialect, sql); assert_eq!( ast, Err(ParserError::ParserError( "Explain must be root of the plan".to_string() )) ); } #[test] fn test_parse_multipart_identifier_positive() { let dialect = TestedDialects::new(vec![Box::new(GenericDialect {})]); // parse multipart with quotes let expected = vec![ Ident { value: "CATALOG".to_string(), quote_style: None, span: Span::empty(), }, Ident { value: "F(o)o. \"bar".to_string(), quote_style: Some('"'), span: Span::empty(), }, Ident { value: "table".to_string(), quote_style: None, span: Span::empty(), }, ]; dialect.run_parser_method(r#"CATALOG."F(o)o. ""bar".table"#, |parser| { let actual = parser.parse_multipart_identifier().unwrap(); assert_eq!(expected, actual); }); // allow whitespace between ident parts let expected = vec![ Ident { value: "CATALOG".to_string(), quote_style: None, span: Span::empty(), }, Ident { value: "table".to_string(), quote_style: None, span: Span::empty(), }, ]; dialect.run_parser_method("CATALOG . table", |parser| { let actual = parser.parse_multipart_identifier().unwrap(); assert_eq!(expected, actual); }); } #[test] fn test_parse_multipart_identifier_negative() { macro_rules! test_parse_multipart_identifier_error { ($input:expr, $expected_err:expr $(,)?) => {{ all_dialects().run_parser_method(&*$input, |parser| { let actual_err = parser.parse_multipart_identifier().unwrap_err(); assert_eq!(actual_err.to_string(), $expected_err); }); }}; } test_parse_multipart_identifier_error!( "", "sql parser error: Empty input when parsing identifier", ); test_parse_multipart_identifier_error!( "*schema.table", "sql parser error: Unexpected token in identifier: *", ); test_parse_multipart_identifier_error!( "schema.table*", "sql parser error: Unexpected token in identifier: *", ); test_parse_multipart_identifier_error!( "schema.table.", "sql parser error: Trailing period in identifier", ); test_parse_multipart_identifier_error!( "schema.*", "sql parser error: Unexpected token following period in identifier: *", ); } #[test] fn test_mysql_partition_selection() { let sql = "SELECT * FROM employees PARTITION (p0, p2)"; let expected = vec!["p0", "p2"]; let ast: Vec = Parser::parse_sql(&MySqlDialect {}, sql).unwrap(); assert_eq!(ast.len(), 1); if let Statement::Query(v) = &ast[0] { if let SetExpr::Select(select) = &*v.body { assert_eq!(select.from.len(), 1); let from: &TableWithJoins = &select.from[0]; let table_factor = &from.relation; if let TableFactor::Table { partitions, .. } = table_factor { let actual: Vec<&str> = partitions .iter() .map(|ident| ident.value.as_str()) .collect(); assert_eq!(expected, actual); } } } else { panic!("fail to parse mysql partition selection"); } } #[test] fn test_replace_into_placeholders() { let sql = "REPLACE INTO t (a) VALUES (&a)"; assert!(Parser::parse_sql(&GenericDialect {}, sql).is_err()); } #[test] fn test_replace_into_set_placeholder() { let sql = "REPLACE INTO t SET ?"; assert!(Parser::parse_sql(&GenericDialect {}, sql).is_err()); } #[test] fn test_replace_incomplete() { let sql = r#"REPLACE"#; assert!(Parser::parse_sql(&MySqlDialect {}, sql).is_err()); } #[test] fn test_placeholder_invalid_whitespace() { for w in [" ", "/*invalid*/"] { let sql = format!("\nSELECT\n :{w}fooBar"); assert!(Parser::parse_sql(&GenericDialect, &sql).is_err()); } } } apache-datafusion-sqlparser-rs-0.62.0/src/test_utils.rs000066400000000000000000000426461517524037000231630ustar00rootroot00000000000000// 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. /// This module contains internal utilities used for testing the library. /// While technically public, the library's users are not supposed to rely /// on this module, as it will change without notice. // // Integration tests (i.e. everything under `tests/`) import this // via `tests/test_utils/helpers`. #[cfg(not(feature = "std"))] use alloc::{ boxed::Box, string::{String, ToString}, vec, vec::Vec, }; use core::fmt::Debug; use crate::dialect::*; use crate::parser::{Parser, ParserError}; use crate::tokenizer::{Token, Tokenizer}; use crate::{ast::*, parser::ParserOptions}; #[cfg(test)] use pretty_assertions::assert_eq; /// Tests use the methods on this struct to invoke the parser on one or /// multiple dialects. pub struct TestedDialects { pub dialects: Vec>, pub options: Option, pub recursion_limit: Option, } impl TestedDialects { /// Create a TestedDialects with default options and the given dialects. pub fn new(dialects: Vec>) -> Self { Self { dialects, options: None, recursion_limit: None, } } pub fn new_with_options(dialects: Vec>, options: ParserOptions) -> Self { Self { dialects, options: Some(options), recursion_limit: None, } } pub fn with_recursion_limit(mut self, recursion_limit: usize) -> Self { self.recursion_limit = Some(recursion_limit); self } fn new_parser<'a>(&self, dialect: &'a dyn Dialect) -> Parser<'a> { let parser = Parser::new(dialect); let parser = if let Some(options) = &self.options { parser.with_options(options.clone()) } else { parser }; let parser = if let Some(recursion_limit) = &self.recursion_limit { parser.with_recursion_limit(*recursion_limit) } else { parser }; parser } /// Run the given function for all of `self.dialects`, assert that they /// return the same result, and return that result. pub fn one_of_identical_results(&self, f: F) -> T where F: Fn(&dyn Dialect) -> T, { let parse_results = self.dialects.iter().map(|dialect| (dialect, f(&**dialect))); parse_results .fold(None, |s, (dialect, parsed)| { if let Some((prev_dialect, prev_parsed)) = s { assert_eq!( prev_parsed, parsed, "Parse results with {prev_dialect:?} are different from {dialect:?}" ); } Some((dialect, parsed)) }) .expect("tested dialects cannot be empty") .1 } pub fn run_parser_method(&self, sql: &str, f: F) -> T where F: Fn(&mut Parser) -> T, { self.one_of_identical_results(|dialect| { let mut parser = self.new_parser(dialect).try_with_sql(sql).unwrap(); f(&mut parser) }) } /// Parses a single SQL string into multiple statements, ensuring /// the result is the same for all tested dialects. pub fn parse_sql_statements(&self, sql: &str) -> Result, ParserError> { self.one_of_identical_results(|dialect| { let mut tokenizer = Tokenizer::new(dialect, sql); if let Some(options) = &self.options { tokenizer = tokenizer.with_unescape(options.unescape); } let tokens = tokenizer.tokenize()?; self.new_parser(dialect) .with_tokens(tokens) .parse_statements() }) // To fail the `ensure_multiple_dialects_are_tested` test: // Parser::parse_sql(&**self.dialects.first().unwrap(), sql) } /// Ensures that `sql` parses as a single [Statement] for all tested /// dialects. /// /// In general, the canonical SQL should be the same (see crate /// documentation for rationale) and you should prefer the `verified_` /// variants in testing, such as [`verified_statement`] or /// [`verified_query`]. /// /// If `canonical` is non empty,this function additionally asserts /// that: /// /// 1. parsing `sql` results in the same [`Statement`] as parsing /// `canonical`. /// /// 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); } let only_statement = statements.pop().unwrap(); if !canonical.is_empty() { assert_eq!(canonical, only_statement.to_string()) } 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 { 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::>() .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 { let ast = self .run_parser_method(sql, |parser| parser.parse_expr()) .unwrap(); assert_eq!(canonical, &ast.to_string()); ast } /// Ensures that `sql` parses as a single [Statement], and that /// re-serializing the parse result produces the same `sql` /// string (is not modified after a serialization round-trip). pub fn verified_stmt(&self, sql: &str) -> Statement { self.one_statement_parses_to(sql, sql) } /// Ensures that `sql` parses as a single [Query], and that /// re-serializing the parse result produces the same `sql` /// string (is not modified after a serialization round-trip). pub fn verified_query(&self, sql: &str) -> Query { match self.verified_stmt(sql) { Statement::Query(query) => *query, _ => panic!("Expected Query"), } } /// Ensures that `sql` parses as a single [Query], and that /// re-serializing the parse result matches the given canonical /// sql string. pub fn verified_query_with_canonical(&self, query: &str, canonical: &str) -> Query { match self.one_statement_parses_to(query, canonical) { Statement::Query(query) => *query, _ => panic!("Expected Query"), } } /// Ensures that `sql` parses as a single [Select], and that /// re-serializing the parse result produces the same `sql` /// string (is not modified after a serialization round-trip). pub fn verified_only_select(&self, query: &str) -> Select { match *self.verified_query(query).body { SetExpr::Select(s) => *s, _ => panic!("Expected SetExpr::Select"), } } /// Ensures that `sql` parses as a single [`Select`], and that additionally: /// /// 1. parsing `sql` results in the same [`Statement`] as parsing /// `canonical`. /// /// 2. re-serializing the result of parsing `sql` produces the same /// `canonical` sql string pub fn verified_only_select_with_canonical(&self, query: &str, canonical: &str) -> Select { let q = match self.one_statement_parses_to(query, canonical) { Statement::Query(query) => *query, _ => panic!("Expected Query"), }; match *q.body { SetExpr::Select(s) => *s, _ => panic!("Expected SetExpr::Select"), } } /// Ensures that `sql` parses as an [`Expr`], and that /// re-serializing the parse result produces the same `sql` /// string (is not modified after a serialization round-trip). 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) { 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. pub fn all_dialects() -> TestedDialects { TestedDialects::new(vec![ Box::new(GenericDialect {}), Box::new(PostgreSqlDialect {}), Box::new(MsSqlDialect {}), Box::new(AnsiDialect {}), Box::new(SnowflakeDialect {}), Box::new(HiveDialect {}), Box::new(RedshiftSqlDialect {}), Box::new(MySqlDialect {}), Box::new(BigQueryDialect {}), Box::new(SQLiteDialect {}), Box::new(DuckDbDialect {}), Box::new(DatabricksDialect {}), Box::new(ClickHouseDialect {}), Box::new(OracleDialect {}), Box::new(TeradataDialect {}), ]) } // Returns all available dialects with the specified parser options pub fn all_dialects_with_options(options: ParserOptions) -> TestedDialects { TestedDialects::new_with_options(all_dialects().dialects, options) } /// Returns all dialects matching the given predicate. pub fn all_dialects_where(predicate: F) -> TestedDialects where F: Fn(&dyn Dialect) -> bool, { let mut dialects = all_dialects(); dialects.dialects.retain(|d| predicate(&**d)); dialects } /// Returns available dialects. The `except` predicate is used /// to filter out specific dialects. pub fn all_dialects_except(except: F) -> TestedDialects where F: Fn(&dyn Dialect) -> bool, { all_dialects_where(|d| !except(d)) } pub fn assert_eq_vec(expected: &[&str], actual: &[T]) { assert_eq!( expected, actual.iter().map(ToString::to_string).collect::>() ); } pub fn only(v: impl IntoIterator) -> T { let mut iter = v.into_iter(); if let (Some(item), None) = (iter.next(), iter.next()) { item } else { panic!("only called on collection without exactly one item") } } pub fn expr_from_projection(item: &SelectItem) -> &Expr { match item { SelectItem::UnnamedExpr(expr) => expr, _ => panic!("Expected UnnamedExpr"), } } pub fn alter_table_op_with_name(stmt: Statement, expected_name: &str) -> AlterTableOperation { match stmt { Statement::AlterTable(alter_table) => { assert_eq!(alter_table.name.to_string(), expected_name); assert!(!alter_table.if_exists); assert!(!alter_table.only); assert_eq!(alter_table.table_type, None); only(alter_table.operations) } _ => panic!("Expected ALTER TABLE statement"), } } pub fn alter_table_op(stmt: Statement) -> AlterTableOperation { alter_table_op_with_name(stmt, "tab") } /// Creates a `Value::Number`, panic'ing if n is not a number pub fn number(n: &str) -> Value { Value::Number(n.parse().unwrap(), false) } /// Creates a [Value::SingleQuotedString] pub fn single_quoted_string(s: impl Into) -> Value { Value::SingleQuotedString(s.into()) } pub fn table_alias(explicit: bool, name: impl Into) -> Option { Some(TableAlias { explicit, name: Ident::new(name), columns: vec![], at: None, }) } pub fn table(name: impl Into) -> TableFactor { TableFactor::Table { name: ObjectName::from(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, with_as_keyword: bool, alias: impl Into, ) -> TableFactor { TableFactor::Table { name: ObjectName::from(vec![Ident::new(name)]), alias: table_alias(with_as_keyword, alias), args: None, with_hints: vec![], version: None, partitions: vec![], with_ordinality: false, json_path: None, sample: None, index_hints: vec![], } } pub fn join(relation: TableFactor) -> Join { Join { relation, global: false, join_operator: JoinOperator::Join(JoinConstraint::Natural), } } pub fn call(function: &str, args: impl IntoIterator) -> Expr { Expr::Function(Function { name: ObjectName::from(vec![Ident::new(function)]), uses_odbc_syntax: false, parameters: FunctionArguments::None, args: FunctionArguments::List(FunctionArgumentList { duplicate_treatment: None, args: args .into_iter() .map(|arg| FunctionArg::Unnamed(FunctionArgExpr::Expr(arg))) .collect(), clauses: vec![], }), filter: None, null_treatment: None, over: None, 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(constraint) => { constraint.columns.first().unwrap().column.expr.clone() } TableConstraint::Unique(constraint) => { constraint.columns.first().unwrap().column.expr.clone() } TableConstraint::PrimaryKey(constraint) => { constraint.columns.first().unwrap().column.expr.clone() } TableConstraint::FulltextOrSpatial(constraint) => { constraint.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(alter_table) => match alter_table.operations.first().unwrap() { AlterTableOperation::AddConstraint { constraint, .. } => { match constraint { TableConstraint::Index(constraint) => { constraint.columns.first().unwrap().column.expr.clone() } TableConstraint::Unique(constraint) => { constraint.columns.first().unwrap().column.expr.clone() } TableConstraint::PrimaryKey(constraint) => { constraint.columns.first().unwrap().column.expr.clone() } TableConstraint::FulltextOrSpatial(constraint) => { constraint.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:?}"), } } apache-datafusion-sqlparser-rs-0.62.0/src/tokenizer.rs000066400000000000000000005335001517524037000227700ustar00rootroot00000000000000// 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. //! SQL Tokenizer //! //! The tokenizer (a.k.a. lexer) converts a string into a sequence of tokens. //! //! The tokens then form the input for the parser, which outputs an Abstract Syntax Tree (AST). #[cfg(not(feature = "std"))] use alloc::{ borrow::ToOwned, format, string::{String, ToString}, vec, vec::Vec, }; use core::num::NonZeroU8; use core::str::Chars; use core::{cmp, fmt}; use core::{iter::Peekable, str}; #[cfg(feature = "serde")] use serde::{Deserialize, Serialize}; #[cfg(feature = "visitor")] use sqlparser_derive::{Visit, VisitMut}; use crate::dialect::Dialect; use crate::dialect::{ BigQueryDialect, DuckDbDialect, GenericDialect, MySqlDialect, PostgreSqlDialect, SnowflakeDialect, }; use crate::keywords::{Keyword, ALL_KEYWORDS, ALL_KEYWORDS_INDEX}; use crate::{ ast::{DollarQuotedString, QuoteDelimitedString}, dialect::HiveDialect, }; /// SQL Token enumeration #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum Token { /// An end-of-file marker, not a real token EOF, /// A keyword (like SELECT) or an optionally quoted SQL identifier Word(Word), /// An unsigned numeric literal Number(String, bool), /// A character that could not be tokenized Char(char), /// Single quoted string: i.e: 'string' SingleQuotedString(String), /// Double quoted string: i.e: "string" DoubleQuotedString(String), /// Triple single quoted strings: Example '''abc''' /// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#quoted_literals) TripleSingleQuotedString(String), /// Triple double quoted strings: Example """abc""" /// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#quoted_literals) TripleDoubleQuotedString(String), /// Dollar quoted string: i.e: $$string$$ or $tag_name$string$tag_name$ DollarQuotedString(DollarQuotedString), /// Byte string literal: i.e: b'string' or B'string' (note that some backends, such as /// PostgreSQL, may treat this syntax as a bit string literal instead, i.e: b'10010101') SingleQuotedByteStringLiteral(String), /// Byte string literal: i.e: b"string" or B"string" DoubleQuotedByteStringLiteral(String), /// Triple single quoted literal with byte string prefix. Example `B'''abc'''` /// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#quoted_literals) TripleSingleQuotedByteStringLiteral(String), /// Triple double quoted literal with byte string prefix. Example `B"""abc"""` /// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#quoted_literals) TripleDoubleQuotedByteStringLiteral(String), /// Single quoted literal with raw string prefix. Example `R'abc'` /// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#quoted_literals) SingleQuotedRawStringLiteral(String), /// Double quoted literal with raw string prefix. Example `R"abc"` /// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#quoted_literals) DoubleQuotedRawStringLiteral(String), /// Triple single quoted literal with raw string prefix. Example `R'''abc'''` /// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#quoted_literals) TripleSingleQuotedRawStringLiteral(String), /// Triple double quoted literal with raw string prefix. Example `R"""abc"""` /// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#quoted_literals) TripleDoubleQuotedRawStringLiteral(String), /// "National" string literal: i.e: N'string' NationalStringLiteral(String), /// Quote delimited literal. Examples `Q'{ab'c}'`, `Q'|ab'c|'`, `Q'|ab|c|'` /// [Oracle](https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/Literals.html#GUID-1824CBAA-6E16-4921-B2A6-112FB02248DA) QuoteDelimitedStringLiteral(QuoteDelimitedString), /// "Nationa" quote delimited literal. Examples `NQ'{ab'c}'`, `NQ'|ab'c|'`, `NQ'|ab|c|'` /// [Oracle](https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/Literals.html#GUID-1824CBAA-6E16-4921-B2A6-112FB02248DA) NationalQuoteDelimitedStringLiteral(QuoteDelimitedString), /// "escaped" string literal, which are an extension to the SQL standard: i.e: e'first \n second' or E 'first \n second' EscapedStringLiteral(String), /// Unicode string literal: i.e: U&'first \000A second' UnicodeStringLiteral(String), /// Hexadecimal string literal: i.e.: X'deadbeef' HexStringLiteral(String), /// Comma Comma, /// Whitespace (space, tab, etc) Whitespace(Whitespace), /// Double equals sign `==` DoubleEq, /// Equality operator `=` Eq, /// Not Equals operator `<>` (or `!=` in some dialects) Neq, /// Less Than operator `<` Lt, /// Greater Than operator `>` Gt, /// Less Than Or Equals operator `<=` LtEq, /// Greater Than Or Equals operator `>=` GtEq, /// Spaceship operator <=> Spaceship, /// Plus operator `+` Plus, /// Minus operator `-` Minus, /// Multiplication operator `*` Mul, /// Division operator `/` Div, /// Integer division operator `//` in DuckDB DuckIntDiv, /// Modulo Operator `%` Mod, /// String concatenation `||` StringConcat, /// Left parenthesis `(` LParen, /// Right parenthesis `)` RParen, /// Period (used for compound identifiers or projections into nested types) Period, /// Colon `:` Colon, /// DoubleColon `::` (used for casting in PostgreSQL) DoubleColon, /// Assignment `:=` (used for keyword argument in DuckDB macros and some functions, and for variable declarations in DuckDB and Snowflake) Assignment, /// SemiColon `;` used as separator for COPY and payload SemiColon, /// Backslash `\` used in terminating the COPY payload with `\.` Backslash, /// Left bracket `[` LBracket, /// Right bracket `]` RBracket, /// Ampersand `&` Ampersand, /// Pipe `|` Pipe, /// Caret `^` Caret, /// Left brace `{` LBrace, /// Right brace `}` RBrace, /// Right Arrow `=>` RArrow, /// Sharp `#` used for PostgreSQL Bitwise XOR operator, also PostgreSQL/Redshift geometrical unary/binary operator (Number of points in path or polygon/Intersection) Sharp, /// `##` PostgreSQL/Redshift geometrical binary operator (Point of closest proximity) DoubleSharp, /// Tilde `~` used for PostgreSQL Bitwise NOT operator or case sensitive match regular expression operator Tilde, /// `~*` , a case insensitive match regular expression operator in PostgreSQL TildeAsterisk, /// `!~` , a case sensitive not match regular expression operator in PostgreSQL ExclamationMarkTilde, /// `!~*` , a case insensitive not match regular expression operator in PostgreSQL ExclamationMarkTildeAsterisk, /// `~~`, a case sensitive match pattern operator in PostgreSQL DoubleTilde, /// `~~*`, a case insensitive match pattern operator in PostgreSQL DoubleTildeAsterisk, /// `!~~`, a case sensitive not match pattern operator in PostgreSQL ExclamationMarkDoubleTilde, /// `!~~*`, a case insensitive not match pattern operator in PostgreSQL ExclamationMarkDoubleTildeAsterisk, /// `<<`, a bitwise shift left operator in PostgreSQL ShiftLeft, /// `>>`, a bitwise shift right operator in PostgreSQL ShiftRight, /// `&&`, an overlap operator in PostgreSQL Overlap, /// Exclamation Mark `!` used for PostgreSQL factorial operator ExclamationMark, /// Double Exclamation Mark `!!` used for PostgreSQL prefix factorial operator DoubleExclamationMark, /// AtSign `@` used for PostgreSQL abs operator, also PostgreSQL/Redshift geometrical unary/binary operator (Center, Contained or on) AtSign, /// `^@`, a "starts with" string operator in PostgreSQL CaretAt, /// `|/`, a square root math operator in PostgreSQL PGSquareRoot, /// `||/`, a cube root math operator in PostgreSQL PGCubeRoot, /// `?` or `$` , a prepared statement arg placeholder Placeholder(String), /// `->`, used as a operator to extract json field in PostgreSQL Arrow, /// `->>`, used as a operator to extract json field as text in PostgreSQL LongArrow, /// `#>`, extracts JSON sub-object at the specified path HashArrow, /// `@-@` PostgreSQL/Redshift geometrical unary operator (Length or circumference) AtDashAt, /// `?-` PostgreSQL/Redshift geometrical unary/binary operator (Is horizontal?/Are horizontally aligned?) QuestionMarkDash, /// `&<` PostgreSQL/Redshift geometrical binary operator (Overlaps to left?) AmpersandLeftAngleBracket, /// `&>` PostgreSQL/Redshift geometrical binary operator (Overlaps to right?)` AmpersandRightAngleBracket, /// `&<|` PostgreSQL/Redshift geometrical binary operator (Does not extend above?)` AmpersandLeftAngleBracketVerticalBar, /// `|&>` PostgreSQL/Redshift geometrical binary operator (Does not extend below?)` VerticalBarAmpersandRightAngleBracket, /// `<->` PostgreSQL/Redshift geometrical binary operator (Distance between) TwoWayArrow, /// `<^` PostgreSQL/Redshift geometrical binary operator (Is below?) LeftAngleBracketCaret, /// `>^` PostgreSQL/Redshift geometrical binary operator (Is above?) RightAngleBracketCaret, /// `?#` PostgreSQL/Redshift geometrical binary operator (Intersects or overlaps) QuestionMarkSharp, /// `?-|` PostgreSQL/Redshift geometrical binary operator (Is perpendicular?) QuestionMarkDashVerticalBar, /// `?||` PostgreSQL/Redshift geometrical binary operator (Are parallel?) QuestionMarkDoubleVerticalBar, /// `~=` PostgreSQL/Redshift geometrical binary operator (Same as) TildeEqual, /// `<<| PostgreSQL/Redshift geometrical binary operator (Is strictly below?) ShiftLeftVerticalBar, /// `|>> PostgreSQL/Redshift geometrical binary operator (Is strictly above?) VerticalBarShiftRight, /// `|> BigQuery pipe operator VerticalBarRightAngleBracket, /// `#>>`, extracts JSON sub-object at the specified path as text HashLongArrow, /// jsonb @> jsonb -> boolean: Test whether left json contains the right json AtArrow, /// jsonb <@ jsonb -> boolean: Test whether right json contains the left json ArrowAt, /// jsonb #- text[] -> jsonb: Deletes the field or array element at the specified /// path, where path elements can be either field keys or array indexes. HashMinus, /// jsonb @? jsonpath -> boolean: Does JSON path return any item for the specified /// JSON value? AtQuestion, /// jsonb @@ jsonpath → boolean: Returns the result of a JSON path predicate check /// for the specified JSON value. Only the first item of the result is taken into /// account. If the result is not Boolean, then NULL is returned. AtAt, /// jsonb ? text -> boolean: Checks whether the string exists as a top-level key within the /// jsonb object Question, /// jsonb ?& text[] -> boolean: Check whether all members of the text array exist as top-level /// keys within the jsonb object QuestionAnd, /// jsonb ?| text[] -> boolean: Check whether any member of the text array exists as top-level /// keys within the jsonb object QuestionPipe, /// Custom binary operator /// This is used to represent any custom binary operator that is not part of the SQL standard. /// PostgreSQL allows defining custom binary operators using CREATE OPERATOR. CustomBinaryOperator(String), } impl fmt::Display for Token { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { Token::EOF => f.write_str("EOF"), Token::Word(ref w) => write!(f, "{w}"), Token::Number(ref n, l) => write!(f, "{}{long}", n, long = if *l { "L" } else { "" }), Token::Char(ref c) => write!(f, "{c}"), Token::SingleQuotedString(ref s) => write!(f, "'{s}'"), Token::TripleSingleQuotedString(ref s) => write!(f, "'''{s}'''"), Token::DoubleQuotedString(ref s) => write!(f, "\"{s}\""), Token::TripleDoubleQuotedString(ref s) => write!(f, "\"\"\"{s}\"\"\""), Token::DollarQuotedString(ref s) => write!(f, "{s}"), Token::NationalStringLiteral(ref s) => write!(f, "N'{s}'"), Token::QuoteDelimitedStringLiteral(ref s) => s.fmt(f), Token::NationalQuoteDelimitedStringLiteral(ref s) => write!(f, "N{s}"), Token::EscapedStringLiteral(ref s) => write!(f, "E'{s}'"), Token::UnicodeStringLiteral(ref s) => write!(f, "U&'{s}'"), Token::HexStringLiteral(ref s) => write!(f, "X'{s}'"), Token::SingleQuotedByteStringLiteral(ref s) => write!(f, "B'{s}'"), Token::TripleSingleQuotedByteStringLiteral(ref s) => write!(f, "B'''{s}'''"), Token::DoubleQuotedByteStringLiteral(ref s) => write!(f, "B\"{s}\""), Token::TripleDoubleQuotedByteStringLiteral(ref s) => write!(f, "B\"\"\"{s}\"\"\""), Token::SingleQuotedRawStringLiteral(ref s) => write!(f, "R'{s}'"), Token::DoubleQuotedRawStringLiteral(ref s) => write!(f, "R\"{s}\""), Token::TripleSingleQuotedRawStringLiteral(ref s) => write!(f, "R'''{s}'''"), Token::TripleDoubleQuotedRawStringLiteral(ref s) => write!(f, "R\"\"\"{s}\"\"\""), Token::Comma => f.write_str(","), Token::Whitespace(ws) => write!(f, "{ws}"), Token::DoubleEq => f.write_str("=="), Token::Spaceship => f.write_str("<=>"), Token::Eq => f.write_str("="), Token::Neq => f.write_str("<>"), Token::Lt => f.write_str("<"), Token::Gt => f.write_str(">"), Token::LtEq => f.write_str("<="), Token::GtEq => f.write_str(">="), Token::Plus => f.write_str("+"), Token::Minus => f.write_str("-"), Token::Mul => f.write_str("*"), Token::Div => f.write_str("/"), Token::DuckIntDiv => f.write_str("//"), Token::StringConcat => f.write_str("||"), Token::Mod => f.write_str("%"), Token::LParen => f.write_str("("), Token::RParen => f.write_str(")"), Token::Period => f.write_str("."), Token::Colon => f.write_str(":"), Token::DoubleColon => f.write_str("::"), Token::Assignment => f.write_str(":="), Token::SemiColon => f.write_str(";"), Token::Backslash => f.write_str("\\"), Token::LBracket => f.write_str("["), Token::RBracket => f.write_str("]"), Token::Ampersand => f.write_str("&"), Token::Caret => f.write_str("^"), Token::Pipe => f.write_str("|"), Token::LBrace => f.write_str("{"), Token::RBrace => f.write_str("}"), Token::RArrow => f.write_str("=>"), Token::Sharp => f.write_str("#"), Token::DoubleSharp => f.write_str("##"), Token::ExclamationMark => f.write_str("!"), Token::DoubleExclamationMark => f.write_str("!!"), Token::Tilde => f.write_str("~"), Token::TildeAsterisk => f.write_str("~*"), Token::ExclamationMarkTilde => f.write_str("!~"), Token::ExclamationMarkTildeAsterisk => f.write_str("!~*"), Token::DoubleTilde => f.write_str("~~"), Token::DoubleTildeAsterisk => f.write_str("~~*"), Token::ExclamationMarkDoubleTilde => f.write_str("!~~"), Token::ExclamationMarkDoubleTildeAsterisk => f.write_str("!~~*"), Token::AtSign => f.write_str("@"), Token::CaretAt => f.write_str("^@"), Token::ShiftLeft => f.write_str("<<"), Token::ShiftRight => f.write_str(">>"), Token::Overlap => f.write_str("&&"), Token::PGSquareRoot => f.write_str("|/"), Token::PGCubeRoot => f.write_str("||/"), Token::AtDashAt => f.write_str("@-@"), Token::QuestionMarkDash => f.write_str("?-"), Token::AmpersandLeftAngleBracket => f.write_str("&<"), Token::AmpersandRightAngleBracket => f.write_str("&>"), Token::AmpersandLeftAngleBracketVerticalBar => f.write_str("&<|"), Token::VerticalBarAmpersandRightAngleBracket => f.write_str("|&>"), Token::VerticalBarRightAngleBracket => f.write_str("|>"), Token::TwoWayArrow => f.write_str("<->"), Token::LeftAngleBracketCaret => f.write_str("<^"), Token::RightAngleBracketCaret => f.write_str(">^"), Token::QuestionMarkSharp => f.write_str("?#"), Token::QuestionMarkDashVerticalBar => f.write_str("?-|"), Token::QuestionMarkDoubleVerticalBar => f.write_str("?||"), Token::TildeEqual => f.write_str("~="), Token::ShiftLeftVerticalBar => f.write_str("<<|"), Token::VerticalBarShiftRight => f.write_str("|>>"), Token::Placeholder(ref s) => write!(f, "{s}"), Token::Arrow => write!(f, "->"), Token::LongArrow => write!(f, "->>"), Token::HashArrow => write!(f, "#>"), Token::HashLongArrow => write!(f, "#>>"), Token::AtArrow => write!(f, "@>"), Token::ArrowAt => write!(f, "<@"), Token::HashMinus => write!(f, "#-"), Token::AtQuestion => write!(f, "@?"), Token::AtAt => write!(f, "@@"), Token::Question => write!(f, "?"), Token::QuestionAnd => write!(f, "?&"), Token::QuestionPipe => write!(f, "?|"), Token::CustomBinaryOperator(s) => f.write_str(s), } } } impl Token { /// Create a `Token::Word` from an unquoted `keyword`. /// /// The lookup is case-insensitive; unknown values become `Keyword::NoKeyword`. pub fn make_keyword(keyword: &str) -> Self { Token::make_word(keyword, None) } /// Create a `Token::Word` from `word` with an optional `quote_style`. /// /// When `quote_style` is `None`, the parser attempts a case-insensitive keyword /// lookup and sets the `Word::keyword` accordingly. pub fn make_word(word: &str, quote_style: Option) -> Self { Token::Word(Word { keyword: keyword_lookup(word, quote_style), value: word.to_string(), quote_style, }) } /// Like [`Self::make_word`] but takes ownership of the word `String`, /// avoiding an extra allocation when the caller already has an owned value. fn make_word_owned(word: String, quote_style: Option) -> Self { Token::Word(Word { keyword: keyword_lookup(&word, quote_style), value: word, quote_style, }) } } /// Case-insensitive keyword lookup using binary search over [`ALL_KEYWORDS`]. fn keyword_lookup(word: &str, quote_style: Option) -> Keyword { if quote_style.is_some() { return Keyword::NoKeyword; } ALL_KEYWORDS .binary_search_by(|probe| { let probe = probe.as_bytes(); let word = word.as_bytes(); for (p, w) in probe.iter().zip(word.iter()) { let cmp = p.cmp(&w.to_ascii_uppercase()); if cmp != core::cmp::Ordering::Equal { return cmp; } } probe.len().cmp(&word.len()) }) .map_or(Keyword::NoKeyword, |x| ALL_KEYWORDS_INDEX[x]) } /// A keyword (like SELECT) or an optionally quoted SQL identifier #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct Word { /// The value of the token, without the enclosing quotes, and with the /// escape sequences (if any) processed (TODO: escapes are not handled) pub value: String, /// An identifier can be "quoted" (<delimited identifier> in ANSI parlance). /// The standard and most implementations allow using double quotes for this, /// but some implementations support other quoting styles as well (e.g. \[MS SQL]) pub quote_style: Option, /// If the word was not quoted and it matched one of the known keywords, /// this will have one of the values from dialect::keywords, otherwise empty pub keyword: Keyword, } impl fmt::Display for Word { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self.quote_style { Some(s) if s == '"' || s == '[' || s == '`' => { write!(f, "{}{}{}", s, self.value, Word::matching_end_quote(s)) } None => f.write_str(&self.value), _ => panic!("Unexpected quote_style!"), } } } impl Word { fn matching_end_quote(ch: char) -> char { match ch { '"' => '"', // ANSI and most dialects '[' => ']', // MS SQL '`' => '`', // MySQL _ => panic!("unexpected quoting style!"), } } } /// Represents whitespace in the input: spaces, newlines, tabs and comments. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub enum Whitespace { /// A single space character. Space, /// A newline character. Newline, /// A tab character. Tab, /// A single-line comment (e.g. `-- comment` or `# comment`). /// The `comment` field contains the text, and `prefix` contains the comment prefix. SingleLineComment { /// The content of the comment (without the prefix). comment: String, /// The prefix used for the comment (for example `--` or `#`). prefix: String, }, /// A multi-line comment (without the `/* ... */` delimiters). MultiLineComment(String), } impl fmt::Display for Whitespace { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { Whitespace::Space => f.write_str(" "), Whitespace::Newline => f.write_str("\n"), Whitespace::Tab => f.write_str("\t"), Whitespace::SingleLineComment { prefix, comment } => write!(f, "{prefix}{comment}"), Whitespace::MultiLineComment(s) => write!(f, "/*{s}*/"), } } } /// Location in input string /// /// # Create an "empty" (unknown) `Location` /// ``` /// # use sqlparser::tokenizer::Location; /// let location = Location::empty(); /// ``` /// /// # Create a `Location` from a line and column /// ``` /// # use sqlparser::tokenizer::Location; /// let location = Location::new(1, 1); /// ``` /// /// # Create a `Location` from a pair /// ``` /// # use sqlparser::tokenizer::Location; /// let location = Location::from((1, 1)); /// ``` #[derive(Eq, PartialEq, Hash, Clone, Copy, Ord, PartialOrd)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct Location { /// Line number, starting from 1. /// /// Note: Line 0 is used for empty spans pub line: u64, /// Line column, starting from 1. /// /// Note: Column 0 is used for empty spans pub column: u64, } impl fmt::Display for Location { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { if self.line == 0 { return Ok(()); } write!(f, " at Line: {}, Column: {}", self.line, self.column) } } impl fmt::Debug for Location { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "Location({},{})", self.line, self.column) } } impl Location { /// Return an "empty" / unknown location pub fn empty() -> Self { Self { line: 0, column: 0 } } /// Create a new `Location` for a given line and column pub fn new(line: u64, column: u64) -> Self { Self { line, column } } /// Create a new location for a given line and column /// /// Alias for [`Self::new`] // TODO: remove / deprecate in favor of` `new` for consistency? pub fn of(line: u64, column: u64) -> Self { Self::new(line, column) } /// Combine self and `end` into a new `Span` pub fn span_to(self, end: Self) -> Span { Span { start: self, end } } } impl From<(u64, u64)> for Location { fn from((line, column): (u64, u64)) -> Self { Self { line, column } } } /// A span represents a linear portion of the input string (start, end) /// /// See [Spanned](crate::ast::Spanned) for more information. #[derive(Eq, PartialEq, Hash, Clone, PartialOrd, Ord, Copy)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] pub struct Span { /// Start `Location` (inclusive). pub start: Location, /// End `Location` (inclusive). pub end: Location, } impl fmt::Debug for Span { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "Span({:?}..{:?})", self.start, self.end) } } impl Span { // An empty span (0, 0) -> (0, 0) // We need a const instance for pattern matching const EMPTY: Span = Self::empty(); /// Create a new span from a start and end [`Location`] pub fn new(start: Location, end: Location) -> Span { Span { start, end } } /// Returns an empty span `(0, 0) -> (0, 0)` /// /// Empty spans represent no knowledge of source location /// See [Spanned](crate::ast::Spanned) for more information. pub const fn empty() -> Span { Span { start: Location { line: 0, column: 0 }, end: Location { line: 0, column: 0 }, } } /// Returns the smallest Span that contains both `self` and `other` /// If either span is [Span::empty], the other span is returned /// /// # Examples /// ``` /// # use sqlparser::tokenizer::{Span, Location}; /// // line 1, column1 -> line 2, column 5 /// let span1 = Span::new(Location::new(1, 1), Location::new(2, 5)); /// // line 2, column 3 -> line 3, column 7 /// let span2 = Span::new(Location::new(2, 3), Location::new(3, 7)); /// // Union of the two is the min/max of the two spans /// // line 1, column 1 -> line 3, column 7 /// let union = span1.union(&span2); /// assert_eq!(union, Span::new(Location::new(1, 1), Location::new(3, 7))); /// ``` pub fn union(&self, other: &Span) -> Span { // If either span is empty, return the other // this prevents propagating (0, 0) through the tree match (self, other) { (&Span::EMPTY, _) => *other, (_, &Span::EMPTY) => *self, _ => Span { start: cmp::min(self.start, other.start), end: cmp::max(self.end, other.end), }, } } /// Same as [Span::union] for `Option` /// /// If `other` is `None`, `self` is returned pub fn union_opt(&self, other: &Option) -> Span { match other { Some(other) => self.union(other), None => *self, } } /// Return the [Span::union] of all spans in the iterator /// /// If the iterator is empty, an empty span is returned /// /// # Example /// ``` /// # use sqlparser::tokenizer::{Span, Location}; /// let spans = vec![ /// Span::new(Location::new(1, 1), Location::new(2, 5)), /// Span::new(Location::new(2, 3), Location::new(3, 7)), /// Span::new(Location::new(3, 1), Location::new(4, 2)), /// ]; /// // line 1, column 1 -> line 4, column 2 /// assert_eq!( /// Span::union_iter(spans), /// Span::new(Location::new(1, 1), Location::new(4, 2)) /// ); pub fn union_iter>(iter: I) -> Span { iter.into_iter() .reduce(|acc, item| acc.union(&item)) .unwrap_or(Span::empty()) } } /// Backwards compatibility struct for [`TokenWithSpan`] #[deprecated(since = "0.53.0", note = "please use `TokenWithSpan` instead")] pub type TokenWithLocation = TokenWithSpan; /// A [Token] with [Span] attached to it /// /// This is used to track the location of a token in the input string /// /// # Examples /// ``` /// # use sqlparser::tokenizer::{Location, Span, Token, TokenWithSpan}; /// // commas @ line 1, column 10 /// let tok1 = TokenWithSpan::new( /// Token::Comma, /// Span::new(Location::new(1, 10), Location::new(1, 11)), /// ); /// assert_eq!(tok1, Token::Comma); // can compare the token /// /// // commas @ line 2, column 20 /// let tok2 = TokenWithSpan::new( /// Token::Comma, /// Span::new(Location::new(2, 20), Location::new(2, 21)), /// ); /// // same token but different locations are not equal /// assert_ne!(tok1, tok2); /// ``` #[derive(Debug, Clone, Hash, Ord, PartialOrd, Eq, PartialEq)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] /// A `Token` together with its `Span` (location in the source). pub struct TokenWithSpan { /// The token value. pub token: Token, /// The span covering the token in the input. pub span: Span, } impl TokenWithSpan { /// Create a new [`TokenWithSpan`] from a [`Token`] and a [`Span`] pub fn new(token: Token, span: Span) -> Self { Self { token, span } } /// Wrap a token with an empty span pub fn wrap(token: Token) -> Self { Self::new(token, Span::empty()) } /// Wrap a token with a location from `start` to `end` pub fn at(token: Token, start: Location, end: Location) -> Self { Self::new(token, Span::new(start, end)) } /// Return an EOF token with no location pub fn new_eof() -> Self { Self::wrap(Token::EOF) } } impl PartialEq for TokenWithSpan { fn eq(&self, other: &Token) -> bool { &self.token == other } } impl PartialEq for Token { fn eq(&self, other: &TokenWithSpan) -> bool { self == &other.token } } impl fmt::Display for TokenWithSpan { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { self.token.fmt(f) } } /// An error reported by the tokenizer, with a human-readable `message` and a `location`. #[derive(Debug, PartialEq, Eq)] pub struct TokenizerError { /// A descriptive error message. pub message: String, /// The `Location` where the error was detected. pub location: Location, } impl fmt::Display for TokenizerError { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "{}{}", self.message, self.location,) } } impl core::error::Error for TokenizerError {} struct State<'a> { peekable: Peekable>, line: u64, col: u64, } impl State<'_> { /// return the next character and advance the stream pub fn next(&mut self) -> Option { match self.peekable.next() { None => None, Some(s) => { if s == '\n' { self.line += 1; self.col = 1; } else { self.col += 1; } Some(s) } } } /// return the next character but do not advance the stream pub fn peek(&mut self) -> Option<&char> { self.peekable.peek() } /// Return the current `Location` (line and column) pub fn location(&self) -> Location { Location { line: self.line, column: self.col, } } } /// Represents how many quote characters enclose a string literal. #[derive(Copy, Clone)] enum NumStringQuoteChars { /// e.g. `"abc"`, `'abc'`, `r'abc'` One, /// e.g. `"""abc"""`, `'''abc'''`, `r'''abc'''` Many(NonZeroU8), } /// Settings for tokenizing a quoted string literal. struct TokenizeQuotedStringSettings { /// The character used to quote the string. quote_style: char, /// Represents how many quotes characters enclose the string literal. num_quote_chars: NumStringQuoteChars, /// The number of opening quotes left to consume, before parsing /// the remaining string literal. /// For example: given initial string `"""abc"""`. If the caller has /// already parsed the first quote for some reason, then this value /// is set to 1, flagging to look to consume only 2 leading quotes. num_opening_quotes_to_consume: u8, /// True if the string uses backslash escaping of special characters /// e.g `'abc\ndef\'ghi' backslash_escape: bool, } /// SQL Tokenizer pub struct Tokenizer<'a> { dialect: &'a dyn Dialect, query: &'a str, /// If true (the default), the tokenizer will un-escape literal /// SQL strings See [`Tokenizer::with_unescape`] for more details. unescape: bool, } impl<'a> Tokenizer<'a> { /// Create a new SQL tokenizer for the specified SQL statement /// /// ``` /// # use sqlparser::tokenizer::{Token, Whitespace, Tokenizer}; /// # use sqlparser::dialect::GenericDialect; /// # let dialect = GenericDialect{}; /// let query = r#"SELECT 'foo'"#; /// /// // Parsing the query /// let tokens = Tokenizer::new(&dialect, &query).tokenize().unwrap(); /// /// assert_eq!(tokens, vec![ /// Token::make_word("SELECT", None), /// Token::Whitespace(Whitespace::Space), /// Token::SingleQuotedString("foo".to_string()), /// ]); pub fn new(dialect: &'a dyn Dialect, query: &'a str) -> Self { Self { dialect, query, unescape: true, } } /// Set unescape mode /// /// When true (default) the tokenizer unescapes literal values /// (for example, `""` in SQL is unescaped to the literal `"`). /// /// When false, the tokenizer provides the raw strings as provided /// in the query. This can be helpful for programs that wish to /// recover the *exact* original query text without normalizing /// the escaping /// /// # Example /// /// ``` /// # use sqlparser::tokenizer::{Token, Tokenizer}; /// # use sqlparser::dialect::GenericDialect; /// # let dialect = GenericDialect{}; /// let query = r#""Foo "" Bar""#; /// let unescaped = Token::make_word(r#"Foo " Bar"#, Some('"')); /// let original = Token::make_word(r#"Foo "" Bar"#, Some('"')); /// /// // Parsing with unescaping (default) /// let tokens = Tokenizer::new(&dialect, &query).tokenize().unwrap(); /// assert_eq!(tokens, vec![unescaped]); /// /// // Parsing with unescape = false /// let tokens = Tokenizer::new(&dialect, &query) /// .with_unescape(false) /// .tokenize().unwrap(); /// assert_eq!(tokens, vec![original]); /// ``` pub fn with_unescape(mut self, unescape: bool) -> Self { self.unescape = unescape; self } /// Tokenize the statement and produce a vector of tokens pub fn tokenize(&mut self) -> Result, TokenizerError> { let twl = self.tokenize_with_location()?; Ok(twl.into_iter().map(|t| t.token).collect()) } /// Tokenize the statement and produce a vector of tokens with location information pub fn tokenize_with_location(&mut self) -> Result, TokenizerError> { let mut tokens: Vec = vec![]; self.tokenize_with_location_into_buf(&mut tokens) .map(|_| tokens) } /// Tokenize the statement and append tokens with location information into the provided buffer. /// If an error is thrown, the buffer will contain all tokens that were successfully parsed before the error. pub fn tokenize_with_location_into_buf( &mut self, buf: &mut Vec, ) -> Result<(), TokenizerError> { self.tokenize_with_location_into_buf_with_mapper(buf, |token| token) } /// Tokenize the statement and produce a vector of tokens, mapping each token /// with provided `mapper` pub fn tokenize_with_location_into_buf_with_mapper( &mut self, buf: &mut Vec, mut mapper: impl FnMut(TokenWithSpan) -> TokenWithSpan, ) -> Result<(), TokenizerError> { let mut state = State { peekable: self.query.chars().peekable(), line: 1, col: 1, }; let mut location = state.location(); while let Some(token) = self.next_token(&mut state, buf.last().map(|t| &t.token))? { let span = location.span_to(state.location()); // Check if this is a multiline comment hint that should be expanded match &token { Token::Whitespace(Whitespace::MultiLineComment(comment)) if self.dialect.supports_multiline_comment_hints() && comment.starts_with('!') => { // Re-tokenize the hints and add them to the buffer self.tokenize_comment_hints(comment, span, buf, &mut mapper)?; } _ => { buf.push(mapper(TokenWithSpan { token, span })); } } location = state.location(); } Ok(()) } /// Re-tokenize optimizer hints from a multiline comment and add them to the buffer. /// For example, `/*!50110 KEY_BLOCK_SIZE = 1024*/` becomes tokens for `KEY_BLOCK_SIZE = 1024` fn tokenize_comment_hints( &self, comment: &str, span: Span, buf: &mut Vec, mut mapper: impl FnMut(TokenWithSpan) -> TokenWithSpan, ) -> Result<(), TokenizerError> { // Strip the leading '!' and any version digits (e.g., "50110") let hint_content = comment .strip_prefix('!') .unwrap_or(comment) .trim_start_matches(|c: char| c.is_ascii_digit()); // If there's no content after stripping, nothing to tokenize if hint_content.is_empty() { return Ok(()); } // Create a new tokenizer for the hint content let inner = Tokenizer::new(self.dialect, hint_content).with_unescape(self.unescape); // Create a state for tracking position within the hint let mut state = State { peekable: hint_content.chars().peekable(), line: span.start.line, col: span.start.column, }; // Tokenize the hint content and add tokens to the buffer let mut location = state.location(); while let Some(token) = inner.next_token(&mut state, buf.last().map(|t| &t.token))? { let token_span = location.span_to(state.location()); buf.push(mapper(TokenWithSpan { token, span: token_span, })); location = state.location(); } Ok(()) } // Tokenize the identifier or keywords in `ch` fn tokenize_identifier_or_keyword( &self, ch: impl IntoIterator, chars: &mut State, ) -> Result, TokenizerError> { chars.next(); // consume the first char let ch: String = ch.into_iter().collect(); let word = self.tokenize_word(ch, chars); // TODO: implement parsing of exponent here if word.chars().all(|x| x.is_ascii_digit() || x == '.') { let mut inner_state = State { peekable: word.chars().peekable(), line: 0, col: 0, }; let mut s = peeking_take_while(&mut inner_state, |ch| matches!(ch, '0'..='9' | '.')); let s2 = peeking_take_while(chars, |ch| matches!(ch, '0'..='9' | '.')); s += s2.as_str(); return Ok(Some(Token::Number(s, false))); } Ok(Some(Token::make_word_owned(word, None))) } /// Get the next token or return None fn next_token( &self, chars: &mut State, prev_token: Option<&Token>, ) -> Result, TokenizerError> { match chars.peek() { Some(&ch) => match ch { ' ' => self.consume_and_return(chars, Token::Whitespace(Whitespace::Space)), '\t' => self.consume_and_return(chars, Token::Whitespace(Whitespace::Tab)), '\n' => self.consume_and_return(chars, Token::Whitespace(Whitespace::Newline)), '\r' => { // Emit a single Whitespace::Newline token for \r and \r\n chars.next(); if let Some('\n') = chars.peek() { chars.next(); } Ok(Some(Token::Whitespace(Whitespace::Newline))) } // BigQuery and MySQL use b or B for byte string literal, Postgres for bit strings b @ 'B' | b @ 'b' if dialect_of!(self is BigQueryDialect | PostgreSqlDialect | MySqlDialect | GenericDialect) => { chars.next(); // consume match chars.peek() { Some('\'') => { if self.dialect.supports_triple_quoted_string() { return self .tokenize_single_or_triple_quoted_string:: Token>( chars, '\'', false, Token::SingleQuotedByteStringLiteral, Token::TripleSingleQuotedByteStringLiteral, ); } let s = self.tokenize_single_quoted_string(chars, '\'', false)?; Ok(Some(Token::SingleQuotedByteStringLiteral(s))) } Some('\"') => { if self.dialect.supports_triple_quoted_string() { return self .tokenize_single_or_triple_quoted_string:: Token>( chars, '"', false, Token::DoubleQuotedByteStringLiteral, Token::TripleDoubleQuotedByteStringLiteral, ); } let s = self.tokenize_single_quoted_string(chars, '\"', false)?; Ok(Some(Token::DoubleQuotedByteStringLiteral(s))) } _ => { // regular identifier starting with an "b" or "B" let s = self.tokenize_word(b, chars); Ok(Some(Token::make_word_owned(s, None))) } } } // BigQuery uses r or R for raw string literal b @ 'R' | b @ 'r' if dialect_of!(self is BigQueryDialect | GenericDialect) => { chars.next(); // consume match chars.peek() { Some('\'') => self .tokenize_single_or_triple_quoted_string:: Token>( chars, '\'', false, Token::SingleQuotedRawStringLiteral, Token::TripleSingleQuotedRawStringLiteral, ), Some('\"') => self .tokenize_single_or_triple_quoted_string:: Token>( chars, '"', false, Token::DoubleQuotedRawStringLiteral, Token::TripleDoubleQuotedRawStringLiteral, ), _ => { // regular identifier starting with an "r" or "R" let s = self.tokenize_word(b, chars); Ok(Some(Token::make_word_owned(s, None))) } } } // Redshift uses lower case n for national string literal n @ 'N' | n @ 'n' => { chars.next(); // consume, to check the next char match chars.peek() { Some('\'') => { // N'...' - a let backslash_escape = self.dialect.supports_string_literal_backslash_escape(); let s = self.tokenize_single_quoted_string(chars, '\'', backslash_escape)?; Ok(Some(Token::NationalStringLiteral(s))) } Some(&q @ 'q') | Some(&q @ 'Q') if self.dialect.supports_quote_delimited_string() => { chars.next(); // consume and check the next char if let Some('\'') = chars.peek() { self.tokenize_quote_delimited_string(chars, &[n, q]) .map(|s| Some(Token::NationalQuoteDelimitedStringLiteral(s))) } else { let s = self.tokenize_word(String::from_iter([n, q]), chars); Ok(Some(Token::make_word_owned(s, None))) } } _ => { // regular identifier starting with an "N" let s = self.tokenize_word(n, chars); Ok(Some(Token::make_word_owned(s, None))) } } } q @ 'Q' | q @ 'q' if self.dialect.supports_quote_delimited_string() => { chars.next(); // consume and check the next char if let Some('\'') = chars.peek() { self.tokenize_quote_delimited_string(chars, &[q]) .map(|s| Some(Token::QuoteDelimitedStringLiteral(s))) } else { let s = self.tokenize_word(q, chars); Ok(Some(Token::make_word_owned(s, None))) } } // PostgreSQL accepts "escape" string constants, which are an extension to the SQL standard. x @ 'e' | x @ 'E' if self.dialect.supports_string_escape_constant() => { let starting_loc = chars.location(); chars.next(); // consume, to check the next char match chars.peek() { Some('\'') => { let s = self.tokenize_escaped_single_quoted_string(starting_loc, chars)?; Ok(Some(Token::EscapedStringLiteral(s))) } _ => { // regular identifier starting with an "E" or "e" let s = self.tokenize_word(x, chars); Ok(Some(Token::make_word_owned(s, None))) } } } // Unicode string literals like U&'first \000A second' are supported in some dialects, including PostgreSQL x @ 'u' | x @ 'U' if self.dialect.supports_unicode_string_literal() => { chars.next(); // consume, to check the next char if chars.peek() == Some(&'&') { // we cannot advance the iterator here, as we need to consume the '&' later if the 'u' was an identifier let mut chars_clone = chars.peekable.clone(); chars_clone.next(); // consume the '&' in the clone if chars_clone.peek() == Some(&'\'') { chars.next(); // consume the '&' in the original iterator let s = unescape_unicode_single_quoted_string(chars)?; return Ok(Some(Token::UnicodeStringLiteral(s))); } } // regular identifier starting with an "U" or "u" let s = self.tokenize_word(x, chars); Ok(Some(Token::make_word_owned(s, None))) } // The spec only allows an uppercase 'X' to introduce a hex // string, but PostgreSQL, at least, allows a lowercase 'x' too. x @ 'x' | x @ 'X' => { chars.next(); // consume, to check the next char match chars.peek() { Some('\'') => { // X'...' - a let s = self.tokenize_single_quoted_string(chars, '\'', true)?; Ok(Some(Token::HexStringLiteral(s))) } _ => { // regular identifier starting with an "X" let s = self.tokenize_word(x, chars); Ok(Some(Token::make_word_owned(s, None))) } } } // single quoted string '\'' => { if self.dialect.supports_triple_quoted_string() { return self .tokenize_single_or_triple_quoted_string:: Token>( chars, '\'', self.dialect.supports_string_literal_backslash_escape(), Token::SingleQuotedString, Token::TripleSingleQuotedString, ); } let s = self.tokenize_single_quoted_string( chars, '\'', self.dialect.supports_string_literal_backslash_escape(), )?; Ok(Some(Token::SingleQuotedString(s))) } // double quoted string '\"' if !self.dialect.is_delimited_identifier_start(ch) && !self.dialect.is_identifier_start(ch) => { if self.dialect.supports_triple_quoted_string() { return self .tokenize_single_or_triple_quoted_string:: Token>( chars, '"', self.dialect.supports_string_literal_backslash_escape(), Token::DoubleQuotedString, Token::TripleDoubleQuotedString, ); } let s = self.tokenize_single_quoted_string( chars, '"', self.dialect.supports_string_literal_backslash_escape(), )?; Ok(Some(Token::DoubleQuotedString(s))) } // delimited (quoted) identifier quote_start if self.dialect.is_delimited_identifier_start(ch) => { let word = self.tokenize_quoted_identifier(quote_start, chars)?; Ok(Some(Token::make_word_owned(word, Some(quote_start)))) } // Potentially nested delimited (quoted) identifier quote_start if self .dialect .is_nested_delimited_identifier_start(quote_start) && self .dialect .peek_nested_delimited_identifier_quotes(chars.peekable.clone()) .is_some() => { let Some((quote_start, nested_quote_start)) = self .dialect .peek_nested_delimited_identifier_quotes(chars.peekable.clone()) else { return self.tokenizer_error( chars.location(), format!("Expected nested delimiter '{quote_start}' before EOF."), ); }; let Some(nested_quote_start) = nested_quote_start else { let word = self.tokenize_quoted_identifier(quote_start, chars)?; return Ok(Some(Token::make_word_owned(word, Some(quote_start)))); }; let mut word = vec![]; let quote_end = Word::matching_end_quote(quote_start); let nested_quote_end = Word::matching_end_quote(nested_quote_start); let error_loc = chars.location(); chars.next(); // skip the first delimiter peeking_take_while(chars, |ch| ch.is_whitespace()); if chars.peek() != Some(&nested_quote_start) { return self.tokenizer_error( error_loc, format!("Expected nested delimiter '{nested_quote_start}' before EOF."), ); } word.push(nested_quote_start.into()); word.push(self.tokenize_quoted_identifier(nested_quote_end, chars)?); word.push(nested_quote_end.into()); peeking_take_while(chars, |ch| ch.is_whitespace()); if chars.peek() != Some("e_end) { return self.tokenizer_error( error_loc, format!("Expected close delimiter '{quote_end}' before EOF."), ); } chars.next(); // skip close delimiter Ok(Some(Token::make_word_owned( word.concat(), Some(quote_start), ))) } // numbers and period '0'..='9' | '.' => { // special case where if ._ is encountered after a word then that word // is a table and the _ is the start of the col name. // if the prev token is not a word, then this is not a valid sql // word or number. if ch == '.' && chars.peekable.clone().nth(1) == Some('_') { if let Some(Token::Word(_)) = prev_token { chars.next(); return Ok(Some(Token::Period)); } return self.tokenizer_error( chars.location(), "Unexpected character '_'".to_string(), ); } // Some dialects support underscore as number separator // There can only be one at a time and it must be followed by another digit let is_number_separator = |ch: char, next_char: Option| { self.dialect.supports_numeric_literal_underscores() && ch == '_' && next_char.is_some_and(|next_ch| next_ch.is_ascii_hexdigit()) }; let mut s = peeking_next_take_while(chars, |ch, next_ch| { ch.is_ascii_digit() || is_number_separator(ch, next_ch) }); // match binary literal that starts with 0x if s == "0" && chars.peek() == Some(&'x') { chars.next(); let s2 = peeking_next_take_while(chars, |ch, next_ch| { ch.is_ascii_hexdigit() || is_number_separator(ch, next_ch) }); return Ok(Some(Token::HexStringLiteral(s2))); } // match one period if let Some('.') = chars.peek() { s.push('.'); chars.next(); } // If the dialect supports identifiers that start with a numeric prefix // and we have now consumed a dot, check if the previous token was a Word. // If so, what follows is definitely not part of a decimal number and // we should yield the dot as a dedicated token so compound identifiers // starting with digits can be parsed correctly. if s == "." && self.dialect.supports_numeric_prefix() { if let Some(Token::Word(_)) = prev_token { return Ok(Some(Token::Period)); } } // Consume fractional digits. s += &peeking_next_take_while(chars, |ch, next_ch| { ch.is_ascii_digit() || is_number_separator(ch, next_ch) }); // No fraction -> Token::Period if s == "." { return Ok(Some(Token::Period)); } // Parse exponent as number let mut exponent_part = String::new(); if chars.peek() == Some(&'e') || chars.peek() == Some(&'E') { let mut char_clone = chars.peekable.clone(); exponent_part.push(char_clone.next().unwrap()); // Optional sign match char_clone.peek() { Some(&c) if matches!(c, '+' | '-') => { exponent_part.push(c); char_clone.next(); } _ => (), } match char_clone.peek() { // Definitely an exponent, get original iterator up to speed and use it Some(&c) if c.is_ascii_digit() => { for _ in 0..exponent_part.len() { chars.next(); } exponent_part += &peeking_take_while(chars, |ch| ch.is_ascii_digit()); s += exponent_part.as_str(); } // Not an exponent, discard the work done _ => (), } } // If the dialect supports identifiers that start with a numeric prefix, // we need to check if the value is in fact an identifier and must thus // be tokenized as a word. if self.dialect.supports_numeric_prefix() { if exponent_part.is_empty() { // If it is not a number with an exponent, it may be // an identifier starting with digits. let word = peeking_take_while(chars, |ch| self.dialect.is_identifier_part(ch)); if !word.is_empty() { s += word.as_str(); return Ok(Some(Token::make_word_owned(s, None))); } } else if prev_token == Some(&Token::Period) { // If the previous token was a period, thus not belonging to a number, // the value we have is part of an identifier. return Ok(Some(Token::make_word_owned(s, None))); } } let long = if chars.peek() == Some(&'L') { chars.next(); true } else { false }; Ok(Some(Token::Number(s, long))) } // punctuation '(' => self.consume_and_return(chars, Token::LParen), ')' => self.consume_and_return(chars, Token::RParen), ',' => self.consume_and_return(chars, Token::Comma), // operators '-' => { chars.next(); // consume the '-' match chars.peek() { Some('-') => { let mut is_comment = true; if self.dialect.requires_single_line_comment_whitespace() { is_comment = chars .peekable .clone() .nth(1) .is_some_and(char::is_whitespace); } if is_comment { chars.next(); // consume second '-' let comment = self.tokenize_single_line_comment(chars); return Ok(Some(Token::Whitespace( Whitespace::SingleLineComment { prefix: "--".to_owned(), comment, }, ))); } self.start_binop(chars, "-", Token::Minus) } Some('>') => { chars.next(); match chars.peek() { Some('>') => self.consume_for_binop(chars, "->>", Token::LongArrow), _ => self.start_binop(chars, "->", Token::Arrow), } } // a regular '-' operator _ => self.start_binop(chars, "-", Token::Minus), } } '/' => { chars.next(); // consume the '/' match chars.peek() { Some('*') => { chars.next(); // consume the '*', starting a multi-line comment self.tokenize_multiline_comment(chars) } Some('/') if dialect_of!(self is SnowflakeDialect) => { chars.next(); // consume the second '/', starting a snowflake single-line comment let comment = self.tokenize_single_line_comment(chars); Ok(Some(Token::Whitespace(Whitespace::SingleLineComment { prefix: "//".to_owned(), comment, }))) } Some('/') if dialect_of!(self is DuckDbDialect | GenericDialect) => { self.consume_and_return(chars, Token::DuckIntDiv) } // a regular '/' operator _ => Ok(Some(Token::Div)), } } '+' => self.consume_and_return(chars, Token::Plus), '*' => self.consume_and_return(chars, Token::Mul), '%' => { chars.next(); // advance past '%' match chars.peek() { Some(s) if s.is_whitespace() => Ok(Some(Token::Mod)), Some(sch) if self.dialect.is_identifier_start('%') => { self.tokenize_identifier_or_keyword([ch, *sch], chars) } _ => self.start_binop(chars, "%", Token::Mod), } } '|' => { chars.next(); // consume the '|' match chars.peek() { Some('/') => self.consume_for_binop(chars, "|/", Token::PGSquareRoot), Some('|') => { chars.next(); // consume the second '|' match chars.peek() { Some('/') => { self.consume_for_binop(chars, "||/", Token::PGCubeRoot) } _ => self.start_binop(chars, "||", Token::StringConcat), } } Some('&') if self.dialect.supports_geometric_types() => { chars.next(); // consume match chars.peek() { Some('>') => self.consume_for_binop( chars, "|&>", Token::VerticalBarAmpersandRightAngleBracket, ), _ => self.start_binop_opt(chars, "|&", None), } } Some('>') if self.dialect.supports_geometric_types() => { chars.next(); // consume match chars.peek() { Some('>') => self.consume_for_binop( chars, "|>>", Token::VerticalBarShiftRight, ), _ => self.start_binop_opt(chars, "|>", None), } } Some('>') if self.dialect.supports_pipe_operator() => { self.consume_for_binop(chars, "|>", Token::VerticalBarRightAngleBracket) } // Bitshift '|' operator _ => self.start_binop(chars, "|", Token::Pipe), } } '=' => { chars.next(); // consume match chars.peek() { Some('>') => self.consume_and_return(chars, Token::RArrow), Some('=') => self.consume_and_return(chars, Token::DoubleEq), _ => Ok(Some(Token::Eq)), } } '!' => { chars.next(); // consume match chars.peek() { Some('=') => self.consume_and_return(chars, Token::Neq), Some('!') => self.consume_and_return(chars, Token::DoubleExclamationMark), Some('~') => { chars.next(); match chars.peek() { Some('*') => self .consume_and_return(chars, Token::ExclamationMarkTildeAsterisk), Some('~') => { chars.next(); match chars.peek() { Some('*') => self.consume_and_return( chars, Token::ExclamationMarkDoubleTildeAsterisk, ), _ => Ok(Some(Token::ExclamationMarkDoubleTilde)), } } _ => Ok(Some(Token::ExclamationMarkTilde)), } } _ => Ok(Some(Token::ExclamationMark)), } } '<' => { chars.next(); // consume match chars.peek() { Some('=') => { chars.next(); match chars.peek() { Some('>') => self.consume_for_binop(chars, "<=>", Token::Spaceship), // `<=+` and `<=-` are not valid combined operators; treat `<=` as // the operator and leave `+`/`-` to be tokenized separately. Some('+') | Some('-') => Ok(Some(Token::LtEq)), _ => self.start_binop(chars, "<=", Token::LtEq), } } Some('|') if self.dialect.supports_geometric_types() => { self.consume_for_binop(chars, "<<|", Token::ShiftLeftVerticalBar) } Some('>') => self.consume_for_binop(chars, "<>", Token::Neq), Some('<') if self.dialect.supports_geometric_types() => { chars.next(); // consume match chars.peek() { Some('|') => self.consume_for_binop( chars, "<<|", Token::ShiftLeftVerticalBar, ), _ => self.start_binop(chars, "<<", Token::ShiftLeft), } } Some('<') => self.consume_for_binop(chars, "<<", Token::ShiftLeft), // `<+` is not a valid combined operator; treat `<` as the operator // and leave `+` to be tokenized separately. Some('+') => Ok(Some(Token::Lt)), Some('-') if self.dialect.supports_geometric_types() => { if chars.peekable.clone().nth(1) == Some('>') { chars.next(); // consume `-` self.consume_for_binop(chars, "<->", Token::TwoWayArrow) } else { Ok(Some(Token::Lt)) } } Some('^') if self.dialect.supports_geometric_types() => { self.consume_for_binop(chars, "<^", Token::LeftAngleBracketCaret) } Some('@') => self.consume_for_binop(chars, "<@", Token::ArrowAt), _ => self.start_binop(chars, "<", Token::Lt), } } '>' => { chars.next(); // consume match chars.peek() { Some('=') => self.consume_for_binop(chars, ">=", Token::GtEq), Some('>') => self.consume_for_binop(chars, ">>", Token::ShiftRight), Some('^') if self.dialect.supports_geometric_types() => { self.consume_for_binop(chars, ">^", Token::RightAngleBracketCaret) } _ => self.start_binop(chars, ">", Token::Gt), } } ':' => { chars.next(); match chars.peek() { Some(':') => self.consume_and_return(chars, Token::DoubleColon), Some('=') => self.consume_and_return(chars, Token::Assignment), _ => Ok(Some(Token::Colon)), } } ';' => self.consume_and_return(chars, Token::SemiColon), '\\' => self.consume_and_return(chars, Token::Backslash), '[' => self.consume_and_return(chars, Token::LBracket), ']' => self.consume_and_return(chars, Token::RBracket), '&' => { chars.next(); // consume the '&' match chars.peek() { Some('>') if self.dialect.supports_geometric_types() => { chars.next(); self.consume_and_return(chars, Token::AmpersandRightAngleBracket) } Some('<') if self.dialect.supports_geometric_types() => { chars.next(); // consume match chars.peek() { Some('|') => self.consume_and_return( chars, Token::AmpersandLeftAngleBracketVerticalBar, ), _ => { self.start_binop(chars, "&<", Token::AmpersandLeftAngleBracket) } } } Some('&') => { chars.next(); // consume the second '&' self.start_binop(chars, "&&", Token::Overlap) } // Bitshift '&' operator _ => self.start_binop(chars, "&", Token::Ampersand), } } '^' => { chars.next(); // consume the '^' match chars.peek() { Some('@') => self.consume_and_return(chars, Token::CaretAt), _ => Ok(Some(Token::Caret)), } } '{' => self.consume_and_return(chars, Token::LBrace), '}' => self.consume_and_return(chars, Token::RBrace), '#' if dialect_of!(self is SnowflakeDialect | BigQueryDialect | MySqlDialect | HiveDialect) => { chars.next(); // consume the '#', starting a snowflake single-line comment let comment = self.tokenize_single_line_comment(chars); Ok(Some(Token::Whitespace(Whitespace::SingleLineComment { prefix: "#".to_owned(), comment, }))) } '~' => { chars.next(); // consume match chars.peek() { Some('*') => self.consume_for_binop(chars, "~*", Token::TildeAsterisk), Some('=') if self.dialect.supports_geometric_types() => { self.consume_for_binop(chars, "~=", Token::TildeEqual) } Some('~') => { chars.next(); match chars.peek() { Some('*') => { self.consume_for_binop(chars, "~~*", Token::DoubleTildeAsterisk) } _ => self.start_binop(chars, "~~", Token::DoubleTilde), } } _ => self.start_binop(chars, "~", Token::Tilde), } } '#' => { chars.next(); match chars.peek() { Some('-') => self.consume_for_binop(chars, "#-", Token::HashMinus), Some('>') => { chars.next(); match chars.peek() { Some('>') => { self.consume_for_binop(chars, "#>>", Token::HashLongArrow) } _ => self.start_binop(chars, "#>", Token::HashArrow), } } Some(' ') => Ok(Some(Token::Sharp)), Some('#') if self.dialect.supports_geometric_types() => { self.consume_for_binop(chars, "##", Token::DoubleSharp) } Some(sch) if self.dialect.is_identifier_start('#') => { self.tokenize_identifier_or_keyword([ch, *sch], chars) } _ => self.start_binop(chars, "#", Token::Sharp), } } '@' => { chars.next(); match chars.peek() { Some('@') if self.dialect.supports_geometric_types() => { self.consume_and_return(chars, Token::AtAt) } Some('-') if self.dialect.supports_geometric_types() => { chars.next(); match chars.peek() { Some('@') => self.consume_and_return(chars, Token::AtDashAt), _ => self.start_binop_opt(chars, "@-", None), } } Some('>') => self.consume_and_return(chars, Token::AtArrow), Some('?') => self.consume_and_return(chars, Token::AtQuestion), Some('@') => { chars.next(); match chars.peek() { Some(' ') => Ok(Some(Token::AtAt)), Some(tch) if self.dialect.is_identifier_start('@') => { self.tokenize_identifier_or_keyword([ch, '@', *tch], chars) } _ => Ok(Some(Token::AtAt)), } } Some(' ') => Ok(Some(Token::AtSign)), // We break on quotes here, because no dialect allows identifiers starting // with @ and containing quotation marks (e.g. `@'foo'`) unless they are // quoted, which is tokenized as a quoted string, not here (e.g. // `"@'foo'"`). Further, at least two dialects parse `@` followed by a // quoted string as two separate tokens, which this allows. For example, // Postgres parses `@'1'` as the absolute value of '1' which is implicitly // cast to a numeric type. And when parsing MySQL-style grantees (e.g. // `GRANT ALL ON *.* to 'root'@'localhost'`), we also want separate tokens // for the user, the `@`, and the host. Some('\'') => Ok(Some(Token::AtSign)), Some('\"') => Ok(Some(Token::AtSign)), Some('`') => Ok(Some(Token::AtSign)), Some(sch) if self.dialect.is_identifier_start('@') => { self.tokenize_identifier_or_keyword([ch, *sch], chars) } _ => Ok(Some(Token::AtSign)), } } // Postgres uses ? for jsonb operators, not prepared statements '?' if self.dialect.supports_geometric_types() => { chars.next(); // consume match chars.peek() { Some('|') => { chars.next(); match chars.peek() { Some('|') => self.consume_and_return( chars, Token::QuestionMarkDoubleVerticalBar, ), _ => Ok(Some(Token::QuestionPipe)), } } Some('&') => self.consume_and_return(chars, Token::QuestionAnd), Some('-') => { chars.next(); // consume match chars.peek() { Some('|') => self .consume_and_return(chars, Token::QuestionMarkDashVerticalBar), _ => Ok(Some(Token::QuestionMarkDash)), } } Some('#') => self.consume_and_return(chars, Token::QuestionMarkSharp), _ => Ok(Some(Token::Question)), } } '?' => { chars.next(); let s = peeking_take_while(chars, |ch| ch.is_numeric()); Ok(Some(Token::Placeholder(format!("?{s}")))) } // identifier or keyword ch if self.dialect.is_identifier_start(ch) => { self.tokenize_identifier_or_keyword([ch], chars) } '$' => Ok(Some(self.tokenize_dollar_preceded_value(chars)?)), // whitespace check (including unicode chars) should be last as it covers some of the chars above ch if ch.is_whitespace() => { self.consume_and_return(chars, Token::Whitespace(Whitespace::Space)) } other => self.consume_and_return(chars, Token::Char(other)), }, None => Ok(None), } } /// Consume the next character, then parse a custom binary operator. The next character should be included in the prefix fn consume_for_binop( &self, chars: &mut State, prefix: &str, default: Token, ) -> Result, TokenizerError> { chars.next(); // consume the first char self.start_binop_opt(chars, prefix, Some(default)) } /// parse a custom binary operator fn start_binop( &self, chars: &mut State, prefix: &str, default: Token, ) -> Result, TokenizerError> { self.start_binop_opt(chars, prefix, Some(default)) } /// parse a custom binary operator fn start_binop_opt( &self, chars: &mut State, prefix: &str, default: Option, ) -> Result, TokenizerError> { let mut custom = None; while let Some(&ch) = chars.peek() { if !self.dialect.is_custom_operator_part(ch) { break; } custom.get_or_insert_with(|| prefix.to_string()).push(ch); chars.next(); } match (custom, default) { (Some(custom), _) => Ok(Token::CustomBinaryOperator(custom).into()), (None, Some(tok)) => Ok(Some(tok)), (None, None) => self.tokenizer_error( chars.location(), format!("Expected a valid binary operator after '{prefix}'"), ), } } /// Tokenize dollar preceded value (i.e: a string/placeholder) fn tokenize_dollar_preceded_value(&self, chars: &mut State) -> Result { let mut s = String::new(); let mut value = String::new(); chars.next(); // If the dialect does not support dollar-quoted strings, then `$$` is rather a placeholder. if matches!(chars.peek(), Some('$')) && !self.dialect.supports_dollar_placeholder() { chars.next(); let mut is_terminated = false; let mut prev: Option = None; while let Some(&ch) = chars.peek() { if prev == Some('$') { if ch == '$' { chars.next(); is_terminated = true; break; } else { s.push('$'); s.push(ch); } } else if ch != '$' { s.push(ch); } prev = Some(ch); chars.next(); } return if chars.peek().is_none() && !is_terminated { self.tokenizer_error(chars.location(), "Unterminated dollar-quoted string") } else { Ok(Token::DollarQuotedString(DollarQuotedString { value: s, tag: None, })) }; } else { value.push_str(&peeking_take_while(chars, |ch| { ch.is_alphanumeric() || ch == '_' // Allow $ as a placeholder character if the dialect supports it || matches!(ch, '$' if self.dialect.supports_dollar_placeholder()) })); // If the dialect supports a dollar sign as a money prefix (e.g. SQL Server), // and the value so far is all digits, check for a decimal part, e.g. `$123.45` if matches!(chars.peek(), Some('.')) && self.dialect.supports_dollar_as_money_prefix() && !value.is_empty() && value.chars().all(|c| c.is_ascii_digit()) { value.push('.'); chars.next(); value.push_str(&peeking_take_while(chars, |ch| ch.is_ascii_digit())); return Ok(Token::Placeholder(format!("${value}"))); } // If the dialect does not support dollar-quoted strings, don't look for the end delimiter. if matches!(chars.peek(), Some('$')) && !self.dialect.supports_dollar_placeholder() { chars.next(); let mut temp = String::new(); let end_delimiter = format!("${value}$"); loop { match chars.next() { Some(ch) => { temp.push(ch); if temp.ends_with(&end_delimiter) { if let Some(temp) = temp.strip_suffix(&end_delimiter) { s.push_str(temp); } break; } } None => { if temp.ends_with(&end_delimiter) { if let Some(temp) = temp.strip_suffix(&end_delimiter) { s.push_str(temp); } break; } return self.tokenizer_error( chars.location(), "Unterminated dollar-quoted, expected $", ); } } } } else { return Ok(Token::Placeholder(format!("${value}"))); } } Ok(Token::DollarQuotedString(DollarQuotedString { value: s, tag: if value.is_empty() { None } else { Some(value) }, })) } fn tokenizer_error( &self, loc: Location, message: impl Into, ) -> Result { Err(TokenizerError { message: message.into(), location: loc, }) } // Consume characters until newline fn tokenize_single_line_comment(&self, chars: &mut State) -> String { let mut comment = peeking_take_while(chars, |ch| match ch { '\n' => false, // Always stop at \n '\r' if dialect_of!(self is PostgreSqlDialect) => false, // Stop at \r for Postgres _ => true, // Keep consuming for other characters }); if let Some(ch) = chars.next() { assert!(ch == '\n' || ch == '\r'); comment.push(ch); } comment } /// Tokenize an identifier or keyword, after the first char is already consumed. fn tokenize_word(&self, first_chars: impl Into, chars: &mut State) -> String { let mut s = first_chars.into(); s.push_str(&peeking_take_while(chars, |ch| { self.dialect.is_identifier_part(ch) })); s } /// Read a quoted identifier fn tokenize_quoted_identifier( &self, quote_start: char, chars: &mut State, ) -> Result { let error_loc = chars.location(); chars.next(); // consume the opening quote let quote_end = Word::matching_end_quote(quote_start); let (s, last_char) = self.parse_quoted_ident(chars, quote_end); if last_char == Some(quote_end) { Ok(s) } else { self.tokenizer_error( error_loc, format!("Expected close delimiter '{quote_end}' before EOF."), ) } } /// Read a single quoted string, starting with the opening quote. fn tokenize_escaped_single_quoted_string( &self, starting_loc: Location, chars: &mut State, ) -> Result { if let Some(s) = unescape_single_quoted_string(chars) { return Ok(s); } self.tokenizer_error(starting_loc, "Unterminated encoded string literal") } /// Reads a string literal quoted by a single or triple quote characters. /// Examples: `'abc'`, `'''abc'''`, `"""abc"""`. fn tokenize_single_or_triple_quoted_string( &self, chars: &mut State, quote_style: char, backslash_escape: bool, single_quote_token: F, triple_quote_token: F, ) -> Result, TokenizerError> where F: Fn(String) -> Token, { let error_loc = chars.location(); let mut num_opening_quotes = 0u8; for _ in 0..3 { if Some("e_style) == chars.peek() { chars.next(); // Consume quote. num_opening_quotes += 1; } else { break; } } let (token_fn, num_quote_chars) = match num_opening_quotes { 1 => (single_quote_token, NumStringQuoteChars::One), 2 => { // If we matched double quotes, then this is an empty string. return Ok(Some(single_quote_token("".into()))); } 3 => { let Some(num_quote_chars) = NonZeroU8::new(3) else { return self.tokenizer_error(error_loc, "invalid number of opening quotes"); }; ( triple_quote_token, NumStringQuoteChars::Many(num_quote_chars), ) } _ => { return self.tokenizer_error(error_loc, "invalid string literal opening"); } }; let settings = TokenizeQuotedStringSettings { quote_style, num_quote_chars, num_opening_quotes_to_consume: 0, backslash_escape, }; self.tokenize_quoted_string(chars, settings) .map(token_fn) .map(Some) } /// Reads a string literal quoted by a single quote character. fn tokenize_single_quoted_string( &self, chars: &mut State, quote_style: char, backslash_escape: bool, ) -> Result { self.tokenize_quoted_string( chars, TokenizeQuotedStringSettings { quote_style, num_quote_chars: NumStringQuoteChars::One, num_opening_quotes_to_consume: 1, backslash_escape, }, ) } /// Reads a quote delimited string expecting `chars.next()` to deliver a quote. /// /// See fn tokenize_quote_delimited_string( &self, chars: &mut State, // the prefix that introduced the possible literal or word, // e.g. "Q" or "nq" literal_prefix: &[char], ) -> Result { let literal_start_loc = chars.location(); chars.next(); let start_quote_loc = chars.location(); let (start_quote, end_quote) = match chars.next() { None | Some(' ') | Some('\t') | Some('\r') | Some('\n') => { return self.tokenizer_error( start_quote_loc, format!( "Invalid space, tab, newline, or EOF after '{}''", String::from_iter(literal_prefix) ), ); } Some(c) => ( c, match c { '[' => ']', '{' => '}', '<' => '>', '(' => ')', c => c, }, ), }; // read the string literal until the "quote character" following a by literal quote let mut value = String::new(); while let Some(ch) = chars.next() { if ch == end_quote { if let Some('\'') = chars.peek() { chars.next(); // ~ consume the quote return Ok(QuoteDelimitedString { start_quote, value, end_quote, }); } } value.push(ch); } self.tokenizer_error(literal_start_loc, "Unterminated string literal") } /// Read a quoted string. fn tokenize_quoted_string( &self, chars: &mut State, settings: TokenizeQuotedStringSettings, ) -> Result { let mut s = String::new(); let error_loc = chars.location(); // Consume any opening quotes. for _ in 0..settings.num_opening_quotes_to_consume { if Some(settings.quote_style) != chars.next() { return self.tokenizer_error(error_loc, "invalid string literal opening"); } } let mut num_consecutive_quotes = 0; while let Some(&ch) = chars.peek() { let pending_final_quote = match settings.num_quote_chars { NumStringQuoteChars::One => Some(NumStringQuoteChars::One), n @ NumStringQuoteChars::Many(count) if num_consecutive_quotes + 1 == count.get() => { Some(n) } NumStringQuoteChars::Many(_) => None, }; match ch { char if char == settings.quote_style && pending_final_quote.is_some() => { chars.next(); // consume if let Some(NumStringQuoteChars::Many(count)) = pending_final_quote { // For an initial string like `"""abc"""`, at this point we have // `abc""` in the buffer and have now matched the final `"`. // However, the string to return is simply `abc`, so we strip off // the trailing quotes before returning. let mut buf = s.chars(); for _ in 1..count.get() { buf.next_back(); } return Ok(buf.as_str().to_string()); } else if chars .peek() .map(|c| *c == settings.quote_style) .unwrap_or(false) { s.push(ch); if !self.unescape { // In no-escape mode, the given query has to be saved completely s.push(ch); } chars.next(); } else { return Ok(s); } } '\\' if settings.backslash_escape => { // consume backslash chars.next(); num_consecutive_quotes = 0; if let Some(next) = chars.peek() { if !self.unescape || (self.dialect.ignores_wildcard_escapes() && (*next == '%' || *next == '_')) { // In no-escape mode, the given query has to be saved completely // including backslashes. Similarly, with ignore_like_wildcard_escapes, // the backslash is not stripped. s.push(ch); s.push(*next); chars.next(); // consume next } else { let n = match next { '0' => '\0', 'a' => '\u{7}', 'b' => '\u{8}', 'f' => '\u{c}', 'n' => '\n', 'r' => '\r', 't' => '\t', 'Z' => '\u{1a}', _ => *next, }; s.push(n); chars.next(); // consume next } } } ch => { chars.next(); // consume ch if ch == settings.quote_style { num_consecutive_quotes += 1; } else { num_consecutive_quotes = 0; } s.push(ch); } } } self.tokenizer_error(error_loc, "Unterminated string literal") } fn tokenize_multiline_comment( &self, chars: &mut State, ) -> Result, TokenizerError> { let mut s = String::new(); let mut nested = 1; let supports_nested_comments = self.dialect.supports_nested_comments(); loop { match chars.next() { Some('/') if matches!(chars.peek(), Some('*')) && supports_nested_comments => { chars.next(); // consume the '*' s.push('/'); s.push('*'); nested += 1; } Some('*') if matches!(chars.peek(), Some('/')) => { chars.next(); // consume the '/' nested -= 1; if nested == 0 { break Ok(Some(Token::Whitespace(Whitespace::MultiLineComment(s)))); } s.push('*'); s.push('/'); } Some(ch) => { s.push(ch); } None => { break self.tokenizer_error( chars.location(), "Unexpected EOF while in a multi-line comment", ); } } } } fn parse_quoted_ident(&self, chars: &mut State, quote_end: char) -> (String, Option) { let mut last_char = None; let mut s = String::new(); while let Some(ch) = chars.next() { if ch == quote_end { if chars.peek() == Some("e_end) { chars.next(); s.push(ch); if !self.unescape { // In no-escape mode, the given query has to be saved completely s.push(ch); } } else { last_char = Some(quote_end); break; } } else { s.push(ch); } } (s, last_char) } #[allow(clippy::unnecessary_wraps)] fn consume_and_return( &self, chars: &mut State, t: Token, ) -> Result, TokenizerError> { chars.next(); Ok(Some(t)) } } /// Read from `chars` until `predicate` returns `false` or EOF is hit. /// Return the characters read as String, and keep the first non-matching /// char available as `chars.next()`. fn peeking_take_while(chars: &mut State, mut predicate: impl FnMut(char) -> bool) -> String { let mut s = String::new(); while let Some(&ch) = chars.peek() { if predicate(ch) { chars.next(); // consume s.push(ch); } else { break; } } s } /// Same as peeking_take_while, but also passes the next character to the predicate. fn peeking_next_take_while( chars: &mut State, mut predicate: impl FnMut(char, Option) -> bool, ) -> String { let mut s = String::new(); while let Some(&ch) = chars.peek() { let next_char = chars.peekable.clone().nth(1); if predicate(ch, next_char) { chars.next(); // consume s.push(ch); } else { break; } } s } fn unescape_single_quoted_string(chars: &mut State<'_>) -> Option { Unescape::new(chars).unescape() } struct Unescape<'a: 'b, 'b> { chars: &'b mut State<'a>, } impl<'a: 'b, 'b> Unescape<'a, 'b> { fn new(chars: &'b mut State<'a>) -> Self { Self { chars } } fn unescape(mut self) -> Option { let mut unescaped = String::new(); self.chars.next(); while let Some(c) = self.chars.next() { if c == '\'' { // case: '''' if self.chars.peek().map(|c| *c == '\'').unwrap_or(false) { self.chars.next(); unescaped.push('\''); continue; } return Some(unescaped); } if c != '\\' { unescaped.push(c); continue; } let c = match self.chars.next()? { 'b' => '\u{0008}', 'f' => '\u{000C}', 'n' => '\n', 'r' => '\r', 't' => '\t', 'u' => self.unescape_unicode_16()?, 'U' => self.unescape_unicode_32()?, 'x' => self.unescape_hex()?, c if c.is_digit(8) => self.unescape_octal(c)?, c => c, }; unescaped.push(Self::check_null(c)?); } None } #[inline] fn check_null(c: char) -> Option { if c == '\0' { None } else { Some(c) } } #[inline] fn byte_to_char(s: &str) -> Option { // u32 is used here because Pg has an overflow operation rather than throwing an exception directly. match u32::from_str_radix(s, RADIX) { Err(_) => None, Ok(n) => { let n = n & 0xFF; if n <= 127 { char::from_u32(n) } else { None } } } } // Hexadecimal byte value. \xh, \xhh (h = 0–9, A–F) fn unescape_hex(&mut self) -> Option { let mut s = String::new(); for _ in 0..2 { match self.next_hex_digit() { Some(c) => s.push(c), None => break, } } if s.is_empty() { return Some('x'); } Self::byte_to_char::<16>(&s) } #[inline] fn next_hex_digit(&mut self) -> Option { match self.chars.peek() { Some(c) if c.is_ascii_hexdigit() => self.chars.next(), _ => None, } } // Octal byte value. \o, \oo, \ooo (o = 0–7) fn unescape_octal(&mut self, c: char) -> Option { let mut s = String::new(); s.push(c); for _ in 0..2 { match self.next_octal_digest() { Some(c) => s.push(c), None => break, } } Self::byte_to_char::<8>(&s) } #[inline] fn next_octal_digest(&mut self) -> Option { match self.chars.peek() { Some(c) if c.is_digit(8) => self.chars.next(), _ => None, } } // 16-bit hexadecimal Unicode character value. \uxxxx (x = 0–9, A–F) fn unescape_unicode_16(&mut self) -> Option { self.unescape_unicode::<4>() } // 32-bit hexadecimal Unicode character value. \Uxxxxxxxx (x = 0–9, A–F) fn unescape_unicode_32(&mut self) -> Option { self.unescape_unicode::<8>() } fn unescape_unicode(&mut self) -> Option { let mut s = String::new(); for _ in 0..NUM { s.push(self.chars.next()?); } match u32::from_str_radix(&s, 16) { Err(_) => None, Ok(n) => char::from_u32(n), } } } fn unescape_unicode_single_quoted_string(chars: &mut State<'_>) -> Result { let mut unescaped = String::new(); chars.next(); // consume the opening quote while let Some(c) = chars.next() { match c { '\'' => { if chars.peek() == Some(&'\'') { chars.next(); unescaped.push('\''); } else { return Ok(unescaped); } } '\\' => match chars.peek() { Some('\\') => { chars.next(); unescaped.push('\\'); } Some('+') => { chars.next(); unescaped.push(take_char_from_hex_digits(chars, 6)?); } _ => unescaped.push(take_char_from_hex_digits(chars, 4)?), }, _ => { unescaped.push(c); } } } Err(TokenizerError { message: "Unterminated unicode encoded string literal".to_string(), location: chars.location(), }) } fn take_char_from_hex_digits( chars: &mut State<'_>, max_digits: usize, ) -> Result { let mut result = 0u32; for _ in 0..max_digits { let next_char = chars.next().ok_or_else(|| TokenizerError { message: "Unexpected EOF while parsing hex digit in escaped unicode string." .to_string(), location: chars.location(), })?; let digit = next_char.to_digit(16).ok_or_else(|| TokenizerError { message: format!("Invalid hex digit in escaped unicode string: {next_char}"), location: chars.location(), })?; result = result * 16 + digit; } char::from_u32(result).ok_or_else(|| TokenizerError { message: format!("Invalid unicode character: {result:x}"), location: chars.location(), }) } #[cfg(test)] mod tests { use super::*; use crate::dialect::{ BigQueryDialect, ClickHouseDialect, HiveDialect, MsSqlDialect, MySqlDialect, PostgreSqlDialect, SQLiteDialect, }; use crate::test_utils::{all_dialects, all_dialects_except, all_dialects_where}; use core::fmt::Debug; #[test] fn tokenizer_error_impl() { let err = TokenizerError { message: "test".into(), location: Location { line: 1, column: 1 }, }; { use core::error::Error; assert!(err.source().is_none()); } assert_eq!(err.to_string(), "test at Line: 1, Column: 1"); } #[test] fn tokenize_select_1() { let sql = String::from("SELECT 1"); let dialect = GenericDialect {}; let tokens = Tokenizer::new(&dialect, &sql).tokenize().unwrap(); let expected = vec![ Token::make_keyword("SELECT"), Token::Whitespace(Whitespace::Space), Token::Number(String::from("1"), false), ]; compare(expected, tokens); } #[test] fn tokenize_select_float() { let sql = String::from("SELECT .1"); let dialect = GenericDialect {}; let tokens = Tokenizer::new(&dialect, &sql).tokenize().unwrap(); let expected = vec![ Token::make_keyword("SELECT"), Token::Whitespace(Whitespace::Space), Token::Number(String::from(".1"), false), ]; compare(expected, tokens); } #[test] fn tokenize_with_mapper() { let sql = String::from("SELECT ?"); let dialect = GenericDialect {}; let mut param_num = 1; let mut tokens = vec![]; Tokenizer::new(&dialect, &sql) .tokenize_with_location_into_buf_with_mapper(&mut tokens, |mut token_span| { token_span.token = match token_span.token { Token::Placeholder(n) => Token::Placeholder(if n == "?" { let ret = format!("${}", param_num); param_num += 1; ret } else { n }), token => token, }; token_span }) .unwrap(); let actual = tokens.into_iter().map(|t| t.token).collect(); let expected = vec![ Token::make_keyword("SELECT"), Token::Whitespace(Whitespace::Space), Token::Placeholder("$1".to_string()), ]; compare(expected, actual); } #[test] fn tokenize_clickhouse_double_equal() { let sql = String::from("SELECT foo=='1'"); let dialect = ClickHouseDialect {}; let mut tokenizer = Tokenizer::new(&dialect, &sql); let tokens = tokenizer.tokenize().unwrap(); let expected = vec![ Token::make_keyword("SELECT"), Token::Whitespace(Whitespace::Space), Token::Word(Word { value: "foo".to_string(), quote_style: None, keyword: Keyword::NoKeyword, }), Token::DoubleEq, Token::SingleQuotedString("1".to_string()), ]; compare(expected, tokens); } #[test] fn tokenize_numeric_literal_underscore() { let dialect = GenericDialect {}; let sql = String::from("SELECT 10_000"); let mut tokenizer = Tokenizer::new(&dialect, &sql); let tokens = tokenizer.tokenize().unwrap(); let expected = vec![ Token::make_keyword("SELECT"), Token::Whitespace(Whitespace::Space), Token::Number("10".to_string(), false), Token::make_word("_000", None), ]; compare(expected, tokens); all_dialects_where(|dialect| dialect.supports_numeric_literal_underscores()).tokenizes_to( "SELECT 10_000, _10_000, 10_00_, 10___0", vec![ Token::make_keyword("SELECT"), Token::Whitespace(Whitespace::Space), Token::Number("10_000".to_string(), false), Token::Comma, Token::Whitespace(Whitespace::Space), Token::make_word("_10_000", None), // leading underscore tokenizes as a word (parsed as column identifier) Token::Comma, Token::Whitespace(Whitespace::Space), Token::Number("10_00".to_string(), false), Token::make_word("_", None), // trailing underscores tokenizes as a word (syntax error in some dialects) Token::Comma, Token::Whitespace(Whitespace::Space), Token::Number("10".to_string(), false), Token::make_word("___0", None), // multiple underscores tokenizes as a word (syntax error in some dialects) ], ); } #[test] fn tokenize_select_exponent() { let sql = String::from("SELECT 1e10, 1e-10, 1e+10, 1ea, 1e-10a, 1e-10-10"); let dialect = GenericDialect {}; let tokens = Tokenizer::new(&dialect, &sql).tokenize().unwrap(); let expected = vec![ Token::make_keyword("SELECT"), Token::Whitespace(Whitespace::Space), Token::Number(String::from("1e10"), false), Token::Comma, Token::Whitespace(Whitespace::Space), Token::Number(String::from("1e-10"), false), Token::Comma, Token::Whitespace(Whitespace::Space), Token::Number(String::from("1e+10"), false), Token::Comma, Token::Whitespace(Whitespace::Space), Token::Number(String::from("1"), false), Token::make_word("ea", None), Token::Comma, Token::Whitespace(Whitespace::Space), Token::Number(String::from("1e-10"), false), Token::make_word("a", None), Token::Comma, Token::Whitespace(Whitespace::Space), Token::Number(String::from("1e-10"), false), Token::Minus, Token::Number(String::from("10"), false), ]; compare(expected, tokens); } #[test] fn tokenize_scalar_function() { let sql = String::from("SELECT sqrt(1)"); let dialect = GenericDialect {}; let tokens = Tokenizer::new(&dialect, &sql).tokenize().unwrap(); let expected = vec![ Token::make_keyword("SELECT"), Token::Whitespace(Whitespace::Space), Token::make_word("sqrt", None), Token::LParen, Token::Number(String::from("1"), false), Token::RParen, ]; compare(expected, tokens); } #[test] fn tokenize_string_string_concat() { let sql = String::from("SELECT 'a' || 'b'"); let dialect = GenericDialect {}; let tokens = Tokenizer::new(&dialect, &sql).tokenize().unwrap(); let expected = vec![ Token::make_keyword("SELECT"), Token::Whitespace(Whitespace::Space), Token::SingleQuotedString(String::from("a")), Token::Whitespace(Whitespace::Space), Token::StringConcat, Token::Whitespace(Whitespace::Space), Token::SingleQuotedString(String::from("b")), ]; compare(expected, tokens); } #[test] fn tokenize_bitwise_op() { let sql = String::from("SELECT one | two ^ three"); let dialect = GenericDialect {}; let tokens = Tokenizer::new(&dialect, &sql).tokenize().unwrap(); let expected = vec![ Token::make_keyword("SELECT"), Token::Whitespace(Whitespace::Space), Token::make_word("one", None), Token::Whitespace(Whitespace::Space), Token::Pipe, Token::Whitespace(Whitespace::Space), Token::make_word("two", None), Token::Whitespace(Whitespace::Space), Token::Caret, Token::Whitespace(Whitespace::Space), Token::make_word("three", None), ]; compare(expected, tokens); } #[test] fn tokenize_logical_xor() { let sql = String::from("SELECT true XOR true, false XOR false, true XOR false, false XOR true"); let dialect = GenericDialect {}; let tokens = Tokenizer::new(&dialect, &sql).tokenize().unwrap(); let expected = vec![ Token::make_keyword("SELECT"), Token::Whitespace(Whitespace::Space), Token::make_keyword("true"), Token::Whitespace(Whitespace::Space), Token::make_keyword("XOR"), Token::Whitespace(Whitespace::Space), Token::make_keyword("true"), Token::Comma, Token::Whitespace(Whitespace::Space), Token::make_keyword("false"), Token::Whitespace(Whitespace::Space), Token::make_keyword("XOR"), Token::Whitespace(Whitespace::Space), Token::make_keyword("false"), Token::Comma, Token::Whitespace(Whitespace::Space), Token::make_keyword("true"), Token::Whitespace(Whitespace::Space), Token::make_keyword("XOR"), Token::Whitespace(Whitespace::Space), Token::make_keyword("false"), Token::Comma, Token::Whitespace(Whitespace::Space), Token::make_keyword("false"), Token::Whitespace(Whitespace::Space), Token::make_keyword("XOR"), Token::Whitespace(Whitespace::Space), Token::make_keyword("true"), ]; compare(expected, tokens); } #[test] fn tokenize_simple_select() { let sql = String::from("SELECT * FROM customer WHERE id = 1 LIMIT 5"); let dialect = GenericDialect {}; let tokens = Tokenizer::new(&dialect, &sql).tokenize().unwrap(); let expected = vec![ Token::make_keyword("SELECT"), Token::Whitespace(Whitespace::Space), Token::Mul, Token::Whitespace(Whitespace::Space), Token::make_keyword("FROM"), Token::Whitespace(Whitespace::Space), Token::make_word("customer", None), Token::Whitespace(Whitespace::Space), Token::make_keyword("WHERE"), Token::Whitespace(Whitespace::Space), Token::make_word("id", None), Token::Whitespace(Whitespace::Space), Token::Eq, Token::Whitespace(Whitespace::Space), Token::Number(String::from("1"), false), Token::Whitespace(Whitespace::Space), Token::make_keyword("LIMIT"), Token::Whitespace(Whitespace::Space), Token::Number(String::from("5"), false), ]; compare(expected, tokens); } #[test] fn tokenize_explain_select() { let sql = String::from("EXPLAIN SELECT * FROM customer WHERE id = 1"); let dialect = GenericDialect {}; let tokens = Tokenizer::new(&dialect, &sql).tokenize().unwrap(); let expected = vec![ Token::make_keyword("EXPLAIN"), Token::Whitespace(Whitespace::Space), Token::make_keyword("SELECT"), Token::Whitespace(Whitespace::Space), Token::Mul, Token::Whitespace(Whitespace::Space), Token::make_keyword("FROM"), Token::Whitespace(Whitespace::Space), Token::make_word("customer", None), Token::Whitespace(Whitespace::Space), Token::make_keyword("WHERE"), Token::Whitespace(Whitespace::Space), Token::make_word("id", None), Token::Whitespace(Whitespace::Space), Token::Eq, Token::Whitespace(Whitespace::Space), Token::Number(String::from("1"), false), ]; compare(expected, tokens); } #[test] fn tokenize_explain_analyze_select() { let sql = String::from("EXPLAIN ANALYZE SELECT * FROM customer WHERE id = 1"); let dialect = GenericDialect {}; let tokens = Tokenizer::new(&dialect, &sql).tokenize().unwrap(); let expected = vec![ Token::make_keyword("EXPLAIN"), Token::Whitespace(Whitespace::Space), Token::make_keyword("ANALYZE"), Token::Whitespace(Whitespace::Space), Token::make_keyword("SELECT"), Token::Whitespace(Whitespace::Space), Token::Mul, Token::Whitespace(Whitespace::Space), Token::make_keyword("FROM"), Token::Whitespace(Whitespace::Space), Token::make_word("customer", None), Token::Whitespace(Whitespace::Space), Token::make_keyword("WHERE"), Token::Whitespace(Whitespace::Space), Token::make_word("id", None), Token::Whitespace(Whitespace::Space), Token::Eq, Token::Whitespace(Whitespace::Space), Token::Number(String::from("1"), false), ]; compare(expected, tokens); } #[test] fn tokenize_string_predicate() { let sql = String::from("SELECT * FROM customer WHERE salary != 'Not Provided'"); let dialect = GenericDialect {}; let tokens = Tokenizer::new(&dialect, &sql).tokenize().unwrap(); let expected = vec![ Token::make_keyword("SELECT"), Token::Whitespace(Whitespace::Space), Token::Mul, Token::Whitespace(Whitespace::Space), Token::make_keyword("FROM"), Token::Whitespace(Whitespace::Space), Token::make_word("customer", None), Token::Whitespace(Whitespace::Space), Token::make_keyword("WHERE"), Token::Whitespace(Whitespace::Space), Token::make_word("salary", None), Token::Whitespace(Whitespace::Space), Token::Neq, Token::Whitespace(Whitespace::Space), Token::SingleQuotedString(String::from("Not Provided")), ]; compare(expected, tokens); } #[test] fn tokenize_invalid_string() { let sql = String::from("\n💝مصطفىh"); let dialect = GenericDialect {}; let tokens = Tokenizer::new(&dialect, &sql).tokenize().unwrap(); // println!("tokens: {:#?}", tokens); let expected = vec![ Token::Whitespace(Whitespace::Newline), Token::Char('💝'), Token::make_word("مصطفىh", None), ]; compare(expected, tokens); } #[test] fn tokenize_newline_in_string_literal() { let sql = String::from("'foo\r\nbar\nbaz'"); let dialect = GenericDialect {}; let tokens = Tokenizer::new(&dialect, &sql).tokenize().unwrap(); let expected = vec![Token::SingleQuotedString("foo\r\nbar\nbaz".to_string())]; compare(expected, tokens); } #[test] fn tokenize_unterminated_string_literal() { let sql = String::from("select 'foo"); let dialect = GenericDialect {}; let mut tokenizer = Tokenizer::new(&dialect, &sql); assert_eq!( tokenizer.tokenize(), Err(TokenizerError { message: "Unterminated string literal".to_string(), location: Location { line: 1, column: 8 }, }) ); } #[test] fn tokenize_unterminated_string_literal_utf8() { let sql = String::from("SELECT \"なにか\" FROM Y WHERE \"なにか\" = 'test;"); let dialect = GenericDialect {}; let mut tokenizer = Tokenizer::new(&dialect, &sql); assert_eq!( tokenizer.tokenize(), Err(TokenizerError { message: "Unterminated string literal".to_string(), location: Location { line: 1, column: 35 } }) ); } #[test] fn tokenize_invalid_string_cols() { let sql = String::from("\n\nSELECT * FROM table\t💝مصطفىh"); let dialect = GenericDialect {}; let tokens = Tokenizer::new(&dialect, &sql).tokenize().unwrap(); // println!("tokens: {:#?}", tokens); let expected = vec![ Token::Whitespace(Whitespace::Newline), Token::Whitespace(Whitespace::Newline), Token::make_keyword("SELECT"), Token::Whitespace(Whitespace::Space), Token::Mul, Token::Whitespace(Whitespace::Space), Token::make_keyword("FROM"), Token::Whitespace(Whitespace::Space), Token::make_keyword("table"), Token::Whitespace(Whitespace::Tab), Token::Char('💝'), Token::make_word("مصطفىh", None), ]; compare(expected, tokens); } #[test] fn tokenize_dollar_quoted_string_tagged() { let test_cases = vec![ ( String::from("SELECT $tag$dollar '$' quoted strings have $tags like this$ or like this $$$tag$"), vec![ Token::make_keyword("SELECT"), Token::Whitespace(Whitespace::Space), Token::DollarQuotedString(DollarQuotedString { value: "dollar '$' quoted strings have $tags like this$ or like this $$".into(), tag: Some("tag".into()), }) ] ), ( String::from("SELECT $abc$x$ab$abc$"), vec![ Token::make_keyword("SELECT"), Token::Whitespace(Whitespace::Space), Token::DollarQuotedString(DollarQuotedString { value: "x$ab".into(), tag: Some("abc".into()), }) ] ), ( String::from("SELECT $abc$$abc$"), vec![ Token::make_keyword("SELECT"), Token::Whitespace(Whitespace::Space), Token::DollarQuotedString(DollarQuotedString { value: "".into(), tag: Some("abc".into()), }) ] ), ( String::from("0$abc$$abc$1"), vec![ Token::Number("0".into(), false), Token::DollarQuotedString(DollarQuotedString { value: "".into(), tag: Some("abc".into()), }), Token::Number("1".into(), false), ] ), ( String::from("$function$abc$q$data$q$$function$"), vec![ Token::DollarQuotedString(DollarQuotedString { value: "abc$q$data$q$".into(), tag: Some("function".into()), }), ] ), ]; let dialect = GenericDialect {}; for (sql, expected) in test_cases { let tokens = Tokenizer::new(&dialect, &sql).tokenize().unwrap(); compare(expected, tokens); } } #[test] fn tokenize_dollar_quoted_string_tagged_unterminated() { let sql = String::from("SELECT $tag$dollar '$' quoted strings have $tags like this$ or like this $$$different tag$"); let dialect = GenericDialect {}; assert_eq!( Tokenizer::new(&dialect, &sql).tokenize(), Err(TokenizerError { message: "Unterminated dollar-quoted, expected $".into(), location: Location { line: 1, column: 91 } }) ); } #[test] fn tokenize_dollar_quoted_string_tagged_unterminated_mirror() { let sql = String::from("SELECT $abc$abc$"); let dialect = GenericDialect {}; assert_eq!( Tokenizer::new(&dialect, &sql).tokenize(), Err(TokenizerError { message: "Unterminated dollar-quoted, expected $".into(), location: Location { line: 1, column: 17 } }) ); } #[test] fn tokenize_dollar_placeholder() { let sql = String::from("SELECT $$, $$ABC$$, $ABC$, $ABC"); let dialect = SQLiteDialect {}; let tokens = Tokenizer::new(&dialect, &sql).tokenize().unwrap(); assert_eq!( tokens, vec![ Token::make_keyword("SELECT"), Token::Whitespace(Whitespace::Space), Token::Placeholder("$$".into()), Token::Comma, Token::Whitespace(Whitespace::Space), Token::Placeholder("$$ABC$$".into()), Token::Comma, Token::Whitespace(Whitespace::Space), Token::Placeholder("$ABC$".into()), Token::Comma, Token::Whitespace(Whitespace::Space), Token::Placeholder("$ABC".into()), ] ); } #[test] fn tokenize_nested_dollar_quoted_strings() { let sql = String::from("SELECT $tag$dollar $nested$ string$tag$"); let dialect = GenericDialect {}; let tokens = Tokenizer::new(&dialect, &sql).tokenize().unwrap(); let expected = vec![ Token::make_keyword("SELECT"), Token::Whitespace(Whitespace::Space), Token::DollarQuotedString(DollarQuotedString { value: "dollar $nested$ string".into(), tag: Some("tag".into()), }), ]; compare(expected, tokens); } #[test] fn tokenize_dollar_quoted_string_untagged_empty() { let sql = String::from("SELECT $$$$"); let dialect = GenericDialect {}; let tokens = Tokenizer::new(&dialect, &sql).tokenize().unwrap(); let expected = vec![ Token::make_keyword("SELECT"), Token::Whitespace(Whitespace::Space), Token::DollarQuotedString(DollarQuotedString { value: "".into(), tag: None, }), ]; compare(expected, tokens); } #[test] fn tokenize_dollar_quoted_string_untagged() { let sql = String::from("SELECT $$within dollar '$' quoted strings have $tags like this$ $$"); let dialect = GenericDialect {}; let tokens = Tokenizer::new(&dialect, &sql).tokenize().unwrap(); let expected = vec![ Token::make_keyword("SELECT"), Token::Whitespace(Whitespace::Space), Token::DollarQuotedString(DollarQuotedString { value: "within dollar '$' quoted strings have $tags like this$ ".into(), tag: None, }), ]; compare(expected, tokens); } #[test] fn tokenize_dollar_quoted_string_untagged_unterminated() { let sql = String::from( "SELECT $$dollar '$' quoted strings have $tags like this$ or like this $different tag$", ); let dialect = GenericDialect {}; assert_eq!( Tokenizer::new(&dialect, &sql).tokenize(), Err(TokenizerError { message: "Unterminated dollar-quoted string".into(), location: Location { line: 1, column: 86 } }) ); } #[test] fn tokenize_right_arrow() { let sql = String::from("FUNCTION(key=>value)"); let dialect = GenericDialect {}; let tokens = Tokenizer::new(&dialect, &sql).tokenize().unwrap(); let expected = vec![ Token::make_word("FUNCTION", None), Token::LParen, Token::make_word("key", None), Token::RArrow, Token::make_word("value", None), Token::RParen, ]; compare(expected, tokens); } #[test] fn tokenize_is_null() { let sql = String::from("a IS NULL"); let dialect = GenericDialect {}; let tokens = Tokenizer::new(&dialect, &sql).tokenize().unwrap(); let expected = vec![ Token::make_word("a", None), Token::Whitespace(Whitespace::Space), Token::make_keyword("IS"), Token::Whitespace(Whitespace::Space), Token::make_keyword("NULL"), ]; compare(expected, tokens); } #[test] fn tokenize_comment() { let test_cases = vec![ ( String::from("0--this is a comment\n1"), vec![ Token::Number("0".to_string(), false), Token::Whitespace(Whitespace::SingleLineComment { prefix: "--".to_string(), comment: "this is a comment\n".to_string(), }), Token::Number("1".to_string(), false), ], ), ( String::from("0--this is a comment\r1"), vec![ Token::Number("0".to_string(), false), Token::Whitespace(Whitespace::SingleLineComment { prefix: "--".to_string(), comment: "this is a comment\r1".to_string(), }), ], ), ( String::from("0--this is a comment\r\n1"), vec![ Token::Number("0".to_string(), false), Token::Whitespace(Whitespace::SingleLineComment { prefix: "--".to_string(), comment: "this is a comment\r\n".to_string(), }), Token::Number("1".to_string(), false), ], ), ]; let dialect = GenericDialect {}; for (sql, expected) in test_cases { let tokens = Tokenizer::new(&dialect, &sql).tokenize().unwrap(); compare(expected, tokens); } } #[test] fn tokenize_comment_postgres() { let sql = String::from("1--\r0"); let dialect = PostgreSqlDialect {}; let tokens = Tokenizer::new(&dialect, &sql).tokenize().unwrap(); let expected = vec![ Token::Number("1".to_string(), false), Token::Whitespace(Whitespace::SingleLineComment { prefix: "--".to_string(), comment: "\r".to_string(), }), Token::Number("0".to_string(), false), ]; compare(expected, tokens); } #[test] fn tokenize_comment_at_eof() { let sql = String::from("--this is a comment"); let dialect = GenericDialect {}; let tokens = Tokenizer::new(&dialect, &sql).tokenize().unwrap(); let expected = vec![Token::Whitespace(Whitespace::SingleLineComment { prefix: "--".to_string(), comment: "this is a comment".to_string(), })]; compare(expected, tokens); } #[test] fn tokenize_multiline_comment() { let sql = String::from("0/*multi-line\n* /comment*/1"); let dialect = GenericDialect {}; let tokens = Tokenizer::new(&dialect, &sql).tokenize().unwrap(); let expected = vec![ Token::Number("0".to_string(), false), Token::Whitespace(Whitespace::MultiLineComment( "multi-line\n* /comment".to_string(), )), Token::Number("1".to_string(), false), ]; compare(expected, tokens); } #[test] fn tokenize_nested_multiline_comment() { all_dialects_where(|d| d.supports_nested_comments()).tokenizes_to( "0/*multi-line\n* \n/* comment \n /*comment*/*/ */ /comment*/1", vec![ Token::Number("0".to_string(), false), Token::Whitespace(Whitespace::MultiLineComment( "multi-line\n* \n/* comment \n /*comment*/*/ ".into(), )), Token::Whitespace(Whitespace::Space), Token::Div, Token::Word(Word { value: "comment".to_string(), quote_style: None, keyword: Keyword::COMMENT, }), Token::Mul, Token::Div, Token::Number("1".to_string(), false), ], ); all_dialects_where(|d| d.supports_nested_comments()).tokenizes_to( "0/*multi-line\n* \n/* comment \n /*comment/**/ */ /comment*/*/1", vec![ Token::Number("0".to_string(), false), Token::Whitespace(Whitespace::MultiLineComment( "multi-line\n* \n/* comment \n /*comment/**/ */ /comment*/".into(), )), Token::Number("1".to_string(), false), ], ); all_dialects_where(|d| d.supports_nested_comments()).tokenizes_to( "SELECT 1/* a /* b */ c */0", vec![ Token::make_keyword("SELECT"), Token::Whitespace(Whitespace::Space), Token::Number("1".to_string(), false), Token::Whitespace(Whitespace::MultiLineComment(" a /* b */ c ".to_string())), Token::Number("0".to_string(), false), ], ); } #[test] fn tokenize_nested_multiline_comment_empty() { all_dialects_where(|d| d.supports_nested_comments()).tokenizes_to( "select 1/*/**/*/0", vec![ Token::make_keyword("select"), Token::Whitespace(Whitespace::Space), Token::Number("1".to_string(), false), Token::Whitespace(Whitespace::MultiLineComment("/**/".to_string())), Token::Number("0".to_string(), false), ], ); } #[test] fn tokenize_nested_comments_if_not_supported() { all_dialects_except(|d| d.supports_nested_comments()).tokenizes_to( "SELECT 1/*/* nested comment */*/0", vec![ Token::make_keyword("SELECT"), Token::Whitespace(Whitespace::Space), Token::Number("1".to_string(), false), Token::Whitespace(Whitespace::MultiLineComment( "/* nested comment ".to_string(), )), Token::Mul, Token::Div, Token::Number("0".to_string(), false), ], ); } #[test] fn tokenize_multiline_comment_with_even_asterisks() { let sql = String::from("\n/** Comment **/\n"); let dialect = GenericDialect {}; let tokens = Tokenizer::new(&dialect, &sql).tokenize().unwrap(); let expected = vec![ Token::Whitespace(Whitespace::Newline), Token::Whitespace(Whitespace::MultiLineComment("* Comment *".to_string())), Token::Whitespace(Whitespace::Newline), ]; compare(expected, tokens); } #[test] fn tokenize_unicode_whitespace() { let sql = String::from(" \u{2003}\n"); let dialect = GenericDialect {}; let tokens = Tokenizer::new(&dialect, &sql).tokenize().unwrap(); let expected = vec![ Token::Whitespace(Whitespace::Space), Token::Whitespace(Whitespace::Space), Token::Whitespace(Whitespace::Newline), ]; compare(expected, tokens); } #[test] fn tokenize_mismatched_quotes() { let sql = String::from("\"foo"); let dialect = GenericDialect {}; let mut tokenizer = Tokenizer::new(&dialect, &sql); assert_eq!( tokenizer.tokenize(), Err(TokenizerError { message: "Expected close delimiter '\"' before EOF.".to_string(), location: Location { line: 1, column: 1 }, }) ); } #[test] fn tokenize_newlines() { let sql = String::from("line1\nline2\rline3\r\nline4\r"); let dialect = GenericDialect {}; let tokens = Tokenizer::new(&dialect, &sql).tokenize().unwrap(); let expected = vec![ Token::make_word("line1", None), Token::Whitespace(Whitespace::Newline), Token::make_word("line2", None), Token::Whitespace(Whitespace::Newline), Token::make_word("line3", None), Token::Whitespace(Whitespace::Newline), Token::make_word("line4", None), Token::Whitespace(Whitespace::Newline), ]; compare(expected, tokens); } #[test] fn tokenize_mssql_top() { let sql = "SELECT TOP 5 [bar] FROM foo"; let dialect = MsSqlDialect {}; let tokens = Tokenizer::new(&dialect, sql).tokenize().unwrap(); let expected = vec![ Token::make_keyword("SELECT"), Token::Whitespace(Whitespace::Space), Token::make_keyword("TOP"), Token::Whitespace(Whitespace::Space), Token::Number(String::from("5"), false), Token::Whitespace(Whitespace::Space), Token::make_word("bar", Some('[')), Token::Whitespace(Whitespace::Space), Token::make_keyword("FROM"), Token::Whitespace(Whitespace::Space), Token::make_word("foo", None), ]; compare(expected, tokens); } #[test] fn tokenize_pg_regex_match() { let sql = "SELECT col ~ '^a', col ~* '^a', col !~ '^a', col !~* '^a'"; let dialect = GenericDialect {}; let tokens = Tokenizer::new(&dialect, sql).tokenize().unwrap(); let expected = vec![ Token::make_keyword("SELECT"), Token::Whitespace(Whitespace::Space), Token::make_word("col", None), Token::Whitespace(Whitespace::Space), Token::Tilde, Token::Whitespace(Whitespace::Space), Token::SingleQuotedString("^a".into()), Token::Comma, Token::Whitespace(Whitespace::Space), Token::make_word("col", None), Token::Whitespace(Whitespace::Space), Token::TildeAsterisk, Token::Whitespace(Whitespace::Space), Token::SingleQuotedString("^a".into()), Token::Comma, Token::Whitespace(Whitespace::Space), Token::make_word("col", None), Token::Whitespace(Whitespace::Space), Token::ExclamationMarkTilde, Token::Whitespace(Whitespace::Space), Token::SingleQuotedString("^a".into()), Token::Comma, Token::Whitespace(Whitespace::Space), Token::make_word("col", None), Token::Whitespace(Whitespace::Space), Token::ExclamationMarkTildeAsterisk, Token::Whitespace(Whitespace::Space), Token::SingleQuotedString("^a".into()), ]; compare(expected, tokens); } #[test] fn tokenize_pg_like_match() { let sql = "SELECT col ~~ '_a%', col ~~* '_a%', col !~~ '_a%', col !~~* '_a%'"; let dialect = GenericDialect {}; let tokens = Tokenizer::new(&dialect, sql).tokenize().unwrap(); let expected = vec![ Token::make_keyword("SELECT"), Token::Whitespace(Whitespace::Space), Token::make_word("col", None), Token::Whitespace(Whitespace::Space), Token::DoubleTilde, Token::Whitespace(Whitespace::Space), Token::SingleQuotedString("_a%".into()), Token::Comma, Token::Whitespace(Whitespace::Space), Token::make_word("col", None), Token::Whitespace(Whitespace::Space), Token::DoubleTildeAsterisk, Token::Whitespace(Whitespace::Space), Token::SingleQuotedString("_a%".into()), Token::Comma, Token::Whitespace(Whitespace::Space), Token::make_word("col", None), Token::Whitespace(Whitespace::Space), Token::ExclamationMarkDoubleTilde, Token::Whitespace(Whitespace::Space), Token::SingleQuotedString("_a%".into()), Token::Comma, Token::Whitespace(Whitespace::Space), Token::make_word("col", None), Token::Whitespace(Whitespace::Space), Token::ExclamationMarkDoubleTildeAsterisk, Token::Whitespace(Whitespace::Space), Token::SingleQuotedString("_a%".into()), ]; compare(expected, tokens); } #[test] fn tokenize_quoted_identifier() { let sql = r#" "a "" b" "a """ "c """"" "#; let dialect = GenericDialect {}; let tokens = Tokenizer::new(&dialect, sql).tokenize().unwrap(); let expected = vec![ Token::Whitespace(Whitespace::Space), Token::make_word(r#"a " b"#, Some('"')), Token::Whitespace(Whitespace::Space), Token::make_word(r#"a ""#, Some('"')), Token::Whitespace(Whitespace::Space), Token::make_word(r#"c """#, Some('"')), Token::Whitespace(Whitespace::Space), ]; compare(expected, tokens); } #[test] fn tokenize_snowflake_div() { let sql = r#"field/1000"#; let dialect = SnowflakeDialect {}; let tokens = Tokenizer::new(&dialect, sql).tokenize().unwrap(); let expected = vec![ Token::make_word(r#"field"#, None), Token::Div, Token::Number("1000".to_string(), false), ]; compare(expected, tokens); } #[test] fn tokenize_quoted_identifier_with_no_escape() { let sql = r#" "a "" b" "a """ "c """"" "#; let dialect = GenericDialect {}; let tokens = Tokenizer::new(&dialect, sql) .with_unescape(false) .tokenize() .unwrap(); let expected = vec![ Token::Whitespace(Whitespace::Space), Token::make_word(r#"a "" b"#, Some('"')), Token::Whitespace(Whitespace::Space), Token::make_word(r#"a """#, Some('"')), Token::Whitespace(Whitespace::Space), Token::make_word(r#"c """""#, Some('"')), Token::Whitespace(Whitespace::Space), ]; compare(expected, tokens); } #[test] fn tokenize_with_location() { let sql = "SELECT a,\n b"; let dialect = GenericDialect {}; let tokens = Tokenizer::new(&dialect, sql) .tokenize_with_location() .unwrap(); let expected = vec![ TokenWithSpan::at(Token::make_keyword("SELECT"), (1, 1).into(), (1, 7).into()), TokenWithSpan::at( Token::Whitespace(Whitespace::Space), (1, 7).into(), (1, 8).into(), ), TokenWithSpan::at(Token::make_word("a", None), (1, 8).into(), (1, 9).into()), TokenWithSpan::at(Token::Comma, (1, 9).into(), (1, 10).into()), TokenWithSpan::at( Token::Whitespace(Whitespace::Newline), (1, 10).into(), (2, 1).into(), ), TokenWithSpan::at( Token::Whitespace(Whitespace::Space), (2, 1).into(), (2, 2).into(), ), TokenWithSpan::at(Token::make_word("b", None), (2, 2).into(), (2, 3).into()), ]; compare(expected, tokens); } fn compare(expected: Vec, actual: Vec) { //println!("------------------------------"); //println!("tokens = {:?}", actual); //println!("expected = {:?}", expected); //println!("------------------------------"); assert_eq!(expected, actual); } fn check_unescape(s: &str, expected: Option<&str>) { let s = format!("'{s}'"); let mut state = State { peekable: s.chars().peekable(), line: 0, col: 0, }; assert_eq!( unescape_single_quoted_string(&mut state), expected.map(|s| s.to_string()) ); } #[test] fn test_unescape() { check_unescape(r"\b", Some("\u{0008}")); check_unescape(r"\f", Some("\u{000C}")); check_unescape(r"\t", Some("\t")); check_unescape(r"\r\n", Some("\r\n")); check_unescape(r"\/", Some("/")); check_unescape(r"/", Some("/")); check_unescape(r"\\", Some("\\")); // 16 and 32-bit hexadecimal Unicode character value check_unescape(r"\u0001", Some("\u{0001}")); check_unescape(r"\u4c91", Some("\u{4c91}")); check_unescape(r"\u4c916", Some("\u{4c91}6")); check_unescape(r"\u4c", None); check_unescape(r"\u0000", None); check_unescape(r"\U0010FFFF", Some("\u{10FFFF}")); check_unescape(r"\U00110000", None); check_unescape(r"\U00000000", None); check_unescape(r"\u", None); check_unescape(r"\U", None); check_unescape(r"\U1010FFFF", None); // hexadecimal byte value check_unescape(r"\x4B", Some("\u{004b}")); check_unescape(r"\x4", Some("\u{0004}")); check_unescape(r"\x4L", Some("\u{0004}L")); check_unescape(r"\x", Some("x")); check_unescape(r"\xP", Some("xP")); check_unescape(r"\x0", None); check_unescape(r"\xCAD", None); check_unescape(r"\xA9", None); // octal byte value check_unescape(r"\1", Some("\u{0001}")); check_unescape(r"\12", Some("\u{000a}")); check_unescape(r"\123", Some("\u{0053}")); check_unescape(r"\1232", Some("\u{0053}2")); check_unescape(r"\4", Some("\u{0004}")); check_unescape(r"\45", Some("\u{0025}")); check_unescape(r"\450", Some("\u{0028}")); check_unescape(r"\603", None); check_unescape(r"\0", None); check_unescape(r"\080", None); // others check_unescape(r"\9", Some("9")); check_unescape(r"''", Some("'")); check_unescape( r"Hello\r\nRust/\u4c91 SQL Parser\U0010ABCD\1232", Some("Hello\r\nRust/\u{4c91} SQL Parser\u{10abcd}\u{0053}2"), ); check_unescape(r"Hello\0", None); check_unescape(r"Hello\xCADRust", None); } #[test] fn tokenize_numeric_prefix_trait() { #[derive(Debug)] struct NumericPrefixDialect; impl Dialect for NumericPrefixDialect { fn is_identifier_start(&self, ch: char) -> bool { ch.is_ascii_lowercase() || ch.is_ascii_uppercase() || ch.is_ascii_digit() || ch == '$' } fn is_identifier_part(&self, ch: char) -> bool { ch.is_ascii_lowercase() || ch.is_ascii_uppercase() || ch.is_ascii_digit() || ch == '_' || ch == '$' || ch == '{' || ch == '}' } fn supports_numeric_prefix(&self) -> bool { true } } tokenize_numeric_prefix_inner(&NumericPrefixDialect {}); tokenize_numeric_prefix_inner(&HiveDialect {}); tokenize_numeric_prefix_inner(&MySqlDialect {}); } fn tokenize_numeric_prefix_inner(dialect: &dyn Dialect) { let sql = r#"SELECT * FROM 1"#; let tokens = Tokenizer::new(dialect, sql).tokenize().unwrap(); let expected = vec![ Token::make_keyword("SELECT"), Token::Whitespace(Whitespace::Space), Token::Mul, Token::Whitespace(Whitespace::Space), Token::make_keyword("FROM"), Token::Whitespace(Whitespace::Space), Token::Number(String::from("1"), false), ]; compare(expected, tokens); } #[test] fn tokenize_quoted_string_escape() { let dialect = SnowflakeDialect {}; for (sql, expected, expected_unescaped) in [ (r#"'%a\'%b'"#, r#"%a\'%b"#, r#"%a'%b"#), (r#"'a\'\'b\'c\'d'"#, r#"a\'\'b\'c\'d"#, r#"a''b'c'd"#), (r#"'\\'"#, r#"\\"#, r#"\"#), ( r#"'\0\a\b\f\n\r\t\Z'"#, r#"\0\a\b\f\n\r\t\Z"#, "\0\u{7}\u{8}\u{c}\n\r\t\u{1a}", ), (r#"'\"'"#, r#"\""#, "\""), (r#"'\\a\\b\'c'"#, r#"\\a\\b\'c"#, r#"\a\b'c"#), (r#"'\'abcd'"#, r#"\'abcd"#, r#"'abcd"#), (r#"'''a''b'"#, r#"''a''b"#, r#"'a'b"#), (r#"'\q'"#, r#"\q"#, r#"q"#), (r#"'\%\_'"#, r#"\%\_"#, r#"%_"#), (r#"'\\%\\_'"#, r#"\\%\\_"#, r#"\%\_"#), ] { let tokens = Tokenizer::new(&dialect, sql) .with_unescape(false) .tokenize() .unwrap(); let expected = vec![Token::SingleQuotedString(expected.to_string())]; compare(expected, tokens); let tokens = Tokenizer::new(&dialect, sql) .with_unescape(true) .tokenize() .unwrap(); let expected = vec![Token::SingleQuotedString(expected_unescaped.to_string())]; compare(expected, tokens); } for sql in [r#"'\'"#, r#"'ab\'"#] { let mut tokenizer = Tokenizer::new(&dialect, sql); assert_eq!( "Unterminated string literal", tokenizer.tokenize().unwrap_err().message.as_str(), ); } // Non-escape dialect for (sql, expected) in [(r#"'\'"#, r#"\"#), (r#"'ab\'"#, r#"ab\"#)] { let dialect = GenericDialect {}; let tokens = Tokenizer::new(&dialect, sql).tokenize().unwrap(); let expected = vec![Token::SingleQuotedString(expected.to_string())]; compare(expected, tokens); } // MySQL special case for LIKE escapes for (sql, expected) in [(r#"'\%'"#, r#"\%"#), (r#"'\_'"#, r#"\_"#)] { let dialect = MySqlDialect {}; let tokens = Tokenizer::new(&dialect, sql).tokenize().unwrap(); let expected = vec![Token::SingleQuotedString(expected.to_string())]; compare(expected, tokens); } } #[test] fn tokenize_triple_quoted_string() { fn check( q: char, // The quote character to test r: char, // An alternate quote character. quote_token: F, ) where F: Fn(String) -> Token, { let dialect = BigQueryDialect {}; for (sql, expected, expected_unescaped) in [ // Empty string (format!(r#"{q}{q}{q}{q}{q}{q}"#), "".into(), "".into()), // Should not count escaped quote as end of string. ( format!(r#"{q}{q}{q}ab{q}{q}\{q}{q}cd{q}{q}{q}"#), format!(r#"ab{q}{q}\{q}{q}cd"#), format!(r#"ab{q}{q}{q}{q}cd"#), ), // Simple string ( format!(r#"{q}{q}{q}abc{q}{q}{q}"#), "abc".into(), "abc".into(), ), // Mix single-double quotes unescaped. ( format!(r#"{q}{q}{q}ab{r}{r}{r}c{r}def{r}{r}{r}{q}{q}{q}"#), format!("ab{r}{r}{r}c{r}def{r}{r}{r}"), format!("ab{r}{r}{r}c{r}def{r}{r}{r}"), ), // Escaped quote. ( format!(r#"{q}{q}{q}ab{q}{q}c{q}{q}\{q}de{q}{q}f{q}{q}{q}"#), format!(r#"ab{q}{q}c{q}{q}\{q}de{q}{q}f"#), format!(r#"ab{q}{q}c{q}{q}{q}de{q}{q}f"#), ), // backslash-escaped quote characters. ( format!(r#"{q}{q}{q}a\'\'b\'c\'d{q}{q}{q}"#), r#"a\'\'b\'c\'d"#.into(), r#"a''b'c'd"#.into(), ), // backslash-escaped characters ( format!(r#"{q}{q}{q}abc\0\n\rdef{q}{q}{q}"#), r#"abc\0\n\rdef"#.into(), "abc\0\n\rdef".into(), ), ] { let tokens = Tokenizer::new(&dialect, sql.as_str()) .with_unescape(false) .tokenize() .unwrap(); let expected = vec![quote_token(expected.to_string())]; compare(expected, tokens); let tokens = Tokenizer::new(&dialect, sql.as_str()) .with_unescape(true) .tokenize() .unwrap(); let expected = vec![quote_token(expected_unescaped.to_string())]; compare(expected, tokens); } for sql in [ format!(r#"{q}{q}{q}{q}{q}\{q}"#), format!(r#"{q}{q}{q}abc{q}{q}\{q}"#), format!(r#"{q}{q}{q}{q}"#), format!(r#"{q}{q}{q}{r}{r}"#), format!(r#"{q}{q}{q}abc{q}"#), format!(r#"{q}{q}{q}abc{q}{q}"#), format!(r#"{q}{q}{q}abc"#), ] { let dialect = BigQueryDialect {}; let mut tokenizer = Tokenizer::new(&dialect, sql.as_str()); assert_eq!( "Unterminated string literal", tokenizer.tokenize().unwrap_err().message.as_str(), ); } } check('"', '\'', Token::TripleDoubleQuotedString); check('\'', '"', Token::TripleSingleQuotedString); let dialect = BigQueryDialect {}; let sql = r#"""''"#; let tokens = Tokenizer::new(&dialect, sql) .with_unescape(true) .tokenize() .unwrap(); let expected = vec![ Token::DoubleQuotedString("".to_string()), Token::SingleQuotedString("".to_string()), ]; compare(expected, tokens); let sql = r#"''"""#; let tokens = Tokenizer::new(&dialect, sql) .with_unescape(true) .tokenize() .unwrap(); let expected = vec![ Token::SingleQuotedString("".to_string()), Token::DoubleQuotedString("".to_string()), ]; compare(expected, tokens); // Non-triple quoted string dialect let dialect = SnowflakeDialect {}; let sql = r#"''''''"#; let tokens = Tokenizer::new(&dialect, sql).tokenize().unwrap(); let expected = vec![Token::SingleQuotedString("''".to_string())]; compare(expected, tokens); } #[test] fn test_mysql_users_grantees() { let dialect = MySqlDialect {}; let sql = "CREATE USER `root`@`%`"; let tokens = Tokenizer::new(&dialect, sql).tokenize().unwrap(); let expected = vec![ Token::make_keyword("CREATE"), Token::Whitespace(Whitespace::Space), Token::make_keyword("USER"), Token::Whitespace(Whitespace::Space), Token::make_word("root", Some('`')), Token::AtSign, Token::make_word("%", Some('`')), ]; compare(expected, tokens); } #[test] fn test_postgres_abs_without_space_and_string_literal() { let dialect = MySqlDialect {}; let sql = "SELECT @'1'"; let tokens = Tokenizer::new(&dialect, sql).tokenize().unwrap(); let expected = vec![ Token::make_keyword("SELECT"), Token::Whitespace(Whitespace::Space), Token::AtSign, Token::SingleQuotedString("1".to_string()), ]; compare(expected, tokens); } #[test] fn test_postgres_abs_without_space_and_quoted_column() { let dialect = MySqlDialect {}; let sql = r#"SELECT @"bar" FROM foo"#; let tokens = Tokenizer::new(&dialect, sql).tokenize().unwrap(); let expected = vec![ Token::make_keyword("SELECT"), Token::Whitespace(Whitespace::Space), Token::AtSign, Token::DoubleQuotedString("bar".to_string()), Token::Whitespace(Whitespace::Space), Token::make_keyword("FROM"), Token::Whitespace(Whitespace::Space), Token::make_word("foo", None), ]; compare(expected, tokens); } #[test] fn test_national_strings_backslash_escape_not_supported() { all_dialects_where(|dialect| !dialect.supports_string_literal_backslash_escape()) .tokenizes_to( "select n'''''\\'", vec![ Token::make_keyword("select"), Token::Whitespace(Whitespace::Space), Token::NationalStringLiteral("''\\".to_string()), ], ); } #[test] fn test_national_strings_backslash_escape_supported() { all_dialects_where(|dialect| dialect.supports_string_literal_backslash_escape()) .tokenizes_to( "select n'''''\\''", vec![ Token::make_keyword("select"), Token::Whitespace(Whitespace::Space), Token::NationalStringLiteral("'''".to_string()), ], ); } #[test] fn test_string_escape_constant_not_supported() { all_dialects_where(|dialect| !dialect.supports_string_escape_constant()).tokenizes_to( "select e'...'", vec![ Token::make_keyword("select"), Token::Whitespace(Whitespace::Space), Token::make_word("e", None), Token::SingleQuotedString("...".to_string()), ], ); all_dialects_where(|dialect| !dialect.supports_string_escape_constant()).tokenizes_to( "select E'...'", vec![ Token::make_keyword("select"), Token::Whitespace(Whitespace::Space), Token::make_word("E", None), Token::SingleQuotedString("...".to_string()), ], ); } #[test] fn test_string_escape_constant_supported() { all_dialects_where(|dialect| dialect.supports_string_escape_constant()).tokenizes_to( "select e'\\''", vec![ Token::make_keyword("select"), Token::Whitespace(Whitespace::Space), Token::EscapedStringLiteral("'".to_string()), ], ); all_dialects_where(|dialect| dialect.supports_string_escape_constant()).tokenizes_to( "select E'\\''", vec![ Token::make_keyword("select"), Token::Whitespace(Whitespace::Space), Token::EscapedStringLiteral("'".to_string()), ], ); } #[test] fn test_whitespace_required_after_single_line_comment() { all_dialects_where(|dialect| dialect.requires_single_line_comment_whitespace()) .tokenizes_to( "SELECT --'abc'", vec![ Token::make_keyword("SELECT"), Token::Whitespace(Whitespace::Space), Token::Minus, Token::Minus, Token::SingleQuotedString("abc".to_string()), ], ); all_dialects_where(|dialect| dialect.requires_single_line_comment_whitespace()) .tokenizes_to( "SELECT -- 'abc'", vec![ Token::make_keyword("SELECT"), Token::Whitespace(Whitespace::Space), Token::Whitespace(Whitespace::SingleLineComment { prefix: "--".to_string(), comment: " 'abc'".to_string(), }), ], ); all_dialects_where(|dialect| dialect.requires_single_line_comment_whitespace()) .tokenizes_to( "SELECT --", vec![ Token::make_keyword("SELECT"), Token::Whitespace(Whitespace::Space), Token::Minus, Token::Minus, ], ); all_dialects_where(|d| d.requires_single_line_comment_whitespace()).tokenizes_to( "--\n-- Table structure for table...\n--\n", vec![ Token::Whitespace(Whitespace::SingleLineComment { prefix: "--".to_string(), comment: "\n".to_string(), }), Token::Whitespace(Whitespace::SingleLineComment { prefix: "--".to_string(), comment: " Table structure for table...\n".to_string(), }), Token::Whitespace(Whitespace::SingleLineComment { prefix: "--".to_string(), comment: "\n".to_string(), }), ], ); } #[test] fn test_whitespace_not_required_after_single_line_comment() { all_dialects_where(|dialect| !dialect.requires_single_line_comment_whitespace()) .tokenizes_to( "SELECT --'abc'", vec![ Token::make_keyword("SELECT"), Token::Whitespace(Whitespace::Space), Token::Whitespace(Whitespace::SingleLineComment { prefix: "--".to_string(), comment: "'abc'".to_string(), }), ], ); all_dialects_where(|dialect| !dialect.requires_single_line_comment_whitespace()) .tokenizes_to( "SELECT -- 'abc'", vec![ Token::make_keyword("SELECT"), Token::Whitespace(Whitespace::Space), Token::Whitespace(Whitespace::SingleLineComment { prefix: "--".to_string(), comment: " 'abc'".to_string(), }), ], ); all_dialects_where(|dialect| !dialect.requires_single_line_comment_whitespace()) .tokenizes_to( "SELECT --", vec![ Token::make_keyword("SELECT"), Token::Whitespace(Whitespace::Space), Token::Whitespace(Whitespace::SingleLineComment { prefix: "--".to_string(), comment: "".to_string(), }), ], ); } #[test] fn test_tokenize_identifiers_numeric_prefix() { all_dialects_where(|dialect| dialect.supports_numeric_prefix()) .tokenizes_to("123abc", vec![Token::make_word("123abc", None)]); all_dialects_where(|dialect| dialect.supports_numeric_prefix()) .tokenizes_to("12e34", vec![Token::Number("12e34".to_string(), false)]); all_dialects_where(|dialect| dialect.supports_numeric_prefix()).tokenizes_to( "t.12e34", vec![ Token::make_word("t", None), Token::Period, Token::make_word("12e34", None), ], ); all_dialects_where(|dialect| dialect.supports_numeric_prefix()).tokenizes_to( "t.1two3", vec![ Token::make_word("t", None), Token::Period, Token::make_word("1two3", None), ], ); } #[test] fn tokenize_period_underscore() { let sql = String::from("SELECT table._col"); // a dialect that supports underscores in numeric literals let dialect = PostgreSqlDialect {}; let tokens = Tokenizer::new(&dialect, &sql).tokenize().unwrap(); let expected = vec![ Token::make_keyword("SELECT"), Token::Whitespace(Whitespace::Space), Token::Word(Word { value: "table".to_string(), quote_style: None, keyword: Keyword::TABLE, }), Token::Period, Token::Word(Word { value: "_col".to_string(), quote_style: None, keyword: Keyword::NoKeyword, }), ]; compare(expected, tokens); let sql = String::from("SELECT ._123"); if let Ok(tokens) = Tokenizer::new(&dialect, &sql).tokenize() { panic!("Tokenizer should have failed on {sql}, but it succeeded with {tokens:?}"); } let sql = String::from("SELECT ._abc"); if let Ok(tokens) = Tokenizer::new(&dialect, &sql).tokenize() { panic!("Tokenizer should have failed on {sql}, but it succeeded with {tokens:?}"); } } #[test] fn tokenize_question_mark() { let dialect = PostgreSqlDialect {}; let sql = "SELECT x ? y"; let tokens = Tokenizer::new(&dialect, sql).tokenize().unwrap(); compare( tokens, vec![ Token::make_keyword("SELECT"), Token::Whitespace(Whitespace::Space), Token::make_word("x", None), Token::Whitespace(Whitespace::Space), Token::Question, Token::Whitespace(Whitespace::Space), Token::make_word("y", None), ], ); } #[test] fn tokenize_multiline_comment_with_comment_hint() { let sql = String::from("0/*! word */1"); let dialect = MySqlDialect {}; let tokens = Tokenizer::new(&dialect, &sql).tokenize().unwrap(); let expected = vec![ Token::Number("0".to_string(), false), Token::Whitespace(Whitespace::Space), Token::Word(Word { value: "word".to_string(), quote_style: None, keyword: Keyword::NoKeyword, }), Token::Whitespace(Whitespace::Space), Token::Number("1".to_string(), false), ]; compare(expected, tokens); } #[test] fn tokenize_multiline_comment_with_comment_hint_and_version() { let sql_multi = String::from("0 /*!50110 KEY_BLOCK_SIZE = 1024*/ 1"); let dialect = MySqlDialect {}; let tokens = Tokenizer::new(&dialect, &sql_multi).tokenize().unwrap(); let expected = vec![ Token::Number("0".to_string(), false), Token::Whitespace(Whitespace::Space), Token::Whitespace(Whitespace::Space), Token::Word(Word { value: "KEY_BLOCK_SIZE".to_string(), quote_style: None, keyword: Keyword::KEY_BLOCK_SIZE, }), Token::Whitespace(Whitespace::Space), Token::Eq, Token::Whitespace(Whitespace::Space), Token::Number("1024".to_string(), false), Token::Whitespace(Whitespace::Space), Token::Number("1".to_string(), false), ]; compare(expected, tokens); let tokens = Tokenizer::new(&dialect, "0 /*!50110 */ 1") .tokenize() .unwrap(); compare( vec![ Token::Number("0".to_string(), false), Token::Whitespace(Whitespace::Space), Token::Whitespace(Whitespace::Space), Token::Whitespace(Whitespace::Space), Token::Number("1".to_string(), false), ], tokens, ); let tokens = Tokenizer::new(&dialect, "0 /*!*/ 1").tokenize().unwrap(); compare( vec![ Token::Number("0".to_string(), false), Token::Whitespace(Whitespace::Space), Token::Whitespace(Whitespace::Space), Token::Number("1".to_string(), false), ], tokens, ); let tokens = Tokenizer::new(&dialect, "0 /*! */ 1").tokenize().unwrap(); compare( vec![ Token::Number("0".to_string(), false), Token::Whitespace(Whitespace::Space), Token::Whitespace(Whitespace::Space), Token::Whitespace(Whitespace::Space), Token::Whitespace(Whitespace::Space), Token::Whitespace(Whitespace::Space), Token::Number("1".to_string(), false), ], tokens, ); } #[test] fn tokenize_lt() { all_dialects().tokenizes_to( "select a <-50", vec![ Token::make_keyword("select"), Token::Whitespace(Whitespace::Space), Token::make_word("a", None), Token::Whitespace(Whitespace::Space), Token::Lt, Token::Minus, Token::Number("50".to_string(), false), ], ); all_dialects().tokenizes_to( "select a <+50", vec![ Token::make_keyword("select"), Token::Whitespace(Whitespace::Space), Token::make_word("a", None), Token::Whitespace(Whitespace::Space), Token::Lt, Token::Plus, Token::Number("50".to_string(), false), ], ); all_dialects().tokenizes_to( "select a <=-50", vec![ Token::make_keyword("select"), Token::Whitespace(Whitespace::Space), Token::make_word("a", None), Token::Whitespace(Whitespace::Space), Token::LtEq, Token::Minus, Token::Number("50".to_string(), false), ], ); all_dialects().tokenizes_to( "select a <=+50", vec![ Token::make_keyword("select"), Token::Whitespace(Whitespace::Space), Token::make_word("a", None), Token::Whitespace(Whitespace::Space), Token::LtEq, Token::Plus, Token::Number("50".to_string(), false), ], ); all_dialects_where(|d| d.supports_geometric_types()).tokenizes_to( "select a <->b", vec![ Token::make_keyword("select"), Token::Whitespace(Whitespace::Space), Token::make_word("a", None), Token::Whitespace(Whitespace::Space), Token::TwoWayArrow, Token::make_word("b", None), ], ); all_dialects().tokenizes_to( "select a <-b", vec![ Token::make_keyword("select"), Token::Whitespace(Whitespace::Space), Token::make_word("a", None), Token::Whitespace(Whitespace::Space), Token::Lt, Token::Minus, Token::make_word("b", None), ], ); all_dialects().tokenizes_to( "select a <+b", vec![ Token::make_keyword("select"), Token::Whitespace(Whitespace::Space), Token::make_word("a", None), Token::Whitespace(Whitespace::Space), Token::Lt, Token::Plus, Token::make_word("b", None), ], ); } } apache-datafusion-sqlparser-rs-0.62.0/tests/000077500000000000000000000000001517524037000207555ustar00rootroot00000000000000apache-datafusion-sqlparser-rs-0.62.0/tests/pretty_print.rs000066400000000000000000000173421517524037000240750ustar00rootroot00000000000000// 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() ); } apache-datafusion-sqlparser-rs-0.62.0/tests/queries/000077500000000000000000000000001517524037000224325ustar00rootroot00000000000000apache-datafusion-sqlparser-rs-0.62.0/tests/queries/tpch/000077500000000000000000000000001517524037000233705ustar00rootroot00000000000000apache-datafusion-sqlparser-rs-0.62.0/tests/queries/tpch/1.sql000066400000000000000000000024431517524037000242540ustar00rootroot00000000000000-- 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. select l_returnflag, l_linestatus, sum(l_quantity) as sum_qty, sum(l_extendedprice) as sum_base_price, sum(l_extendedprice * (1 - l_discount)) as sum_disc_price, sum(l_extendedprice * (1 - l_discount) * (1 + l_tax)) as sum_charge, avg(l_quantity) as avg_qty, avg(l_extendedprice) as avg_price, avg(l_discount) as avg_disc, count(*) as count_order from lineitem where l_shipdate <= date '1998-12-01' - interval '90' day (3) group by l_returnflag, l_linestatus order by l_returnflag, l_linestatus; apache-datafusion-sqlparser-rs-0.62.0/tests/queries/tpch/10.sql000066400000000000000000000025461517524037000243400ustar00rootroot00000000000000-- 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. -- using default substitutions select c_custkey, c_name, sum(l_extendedprice * (1 - l_discount)) as revenue, c_acctbal, n_name, c_address, c_phone, c_comment from customer, orders, lineitem, nation where c_custkey = o_custkey and l_orderkey = o_orderkey and o_orderdate >= date '1993-10-01' and o_orderdate < date '1993-10-01' + interval '3' month and l_returnflag = 'R' and c_nationkey = n_nationkey group by c_custkey, c_name, c_acctbal, c_phone, n_name, c_address, c_comment order by revenue desc; apache-datafusion-sqlparser-rs-0.62.0/tests/queries/tpch/11.sql000066400000000000000000000025241517524037000243350ustar00rootroot00000000000000-- 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. -- using default substitutions select ps_partkey, sum(ps_supplycost * ps_availqty) as value from partsupp, supplier, nation where ps_suppkey = s_suppkey and s_nationkey = n_nationkey and n_name = 'GERMANY' group by ps_partkey having sum(ps_supplycost * ps_availqty) > ( select sum(ps_supplycost * ps_availqty) * 0.0001000000 from partsupp, supplier, nation where ps_suppkey = s_suppkey and s_nationkey = n_nationkey and n_name = 'GERMANY' ) order by value desc; apache-datafusion-sqlparser-rs-0.62.0/tests/queries/tpch/12.sql000066400000000000000000000026521517524037000243400ustar00rootroot00000000000000-- 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. -- using default substitutions select l_shipmode, sum(case when o_orderpriority = '1-URGENT' or o_orderpriority = '2-HIGH' then 1 else 0 end) as high_line_count, sum(case when o_orderpriority <> '1-URGENT' and o_orderpriority <> '2-HIGH' then 1 else 0 end) as low_line_count from orders, lineitem where o_orderkey = l_orderkey and l_shipmode in ('MAIL', 'SHIP') and l_commitdate < l_receiptdate and l_shipdate < l_commitdate and l_receiptdate >= date '1994-01-01' and l_receiptdate < date '1994-01-01' + interval '1' year group by l_shipmode order by l_shipmode; apache-datafusion-sqlparser-rs-0.62.0/tests/queries/tpch/13.sql000066400000000000000000000022631517524037000243370ustar00rootroot00000000000000-- 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. -- using default substitutions select c_count, count(*) as custdist from ( select c_custkey, count(o_orderkey) from customer left outer join orders on c_custkey = o_custkey and o_comment not like '%special%requests%' group by c_custkey ) as c_orders (c_custkey, c_count) group by c_count order by custdist desc, c_count desc; apache-datafusion-sqlparser-rs-0.62.0/tests/queries/tpch/14.sql000066400000000000000000000022411517524037000243340ustar00rootroot00000000000000-- 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. -- using default substitutions select 100.00 * sum(case when p_type like 'PROMO%' then l_extendedprice * (1 - l_discount) else 0 end) / sum(l_extendedprice * (1 - l_discount)) as promo_revenue from lineitem, part where l_partkey = p_partkey and l_shipdate >= date '1995-09-01' and l_shipdate < date '1995-09-01' + interval '1' month; apache-datafusion-sqlparser-rs-0.62.0/tests/queries/tpch/15.sql000066400000000000000000000025501517524037000243400ustar00rootroot00000000000000-- 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. -- using default substitutions create view revenue0 (supplier_no, total_revenue) as select l_suppkey, sum(l_extendedprice * (1 - l_discount)) from lineitem where l_shipdate >= date '1996-01-01' and l_shipdate < date '1996-01-01' + interval '3' month group by l_suppkey; select s_suppkey, s_name, s_address, s_phone, total_revenue from supplier, revenue0 where s_suppkey = supplier_no and total_revenue = ( select max(total_revenue) from revenue0 ) order by s_suppkey; drop view revenue0; apache-datafusion-sqlparser-rs-0.62.0/tests/queries/tpch/16.sql000066400000000000000000000024751517524037000243470ustar00rootroot00000000000000-- 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. -- using default substitutions select p_brand, p_type, p_size, count(distinct ps_suppkey) as supplier_cnt from partsupp, part where p_partkey = ps_partkey and p_brand <> 'Brand#45' and p_type not like 'MEDIUM POLISHED%' and p_size in (49, 14, 23, 45, 19, 3, 36, 9) and ps_suppkey not in ( select s_suppkey from supplier where s_comment like '%Customer%Complaints%' ) group by p_brand, p_type, p_size order by supplier_cnt desc, p_brand, p_type, p_size; apache-datafusion-sqlparser-rs-0.62.0/tests/queries/tpch/17.sql000066400000000000000000000021611517524037000243400ustar00rootroot00000000000000-- 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. -- using default substitutions select sum(l_extendedprice) / 7.0 as avg_yearly from lineitem, part where p_partkey = l_partkey and p_brand = 'Brand#23' and p_container = 'MED BOX' and l_quantity < ( select 0.2 * avg(l_quantity) from lineitem where l_partkey = p_partkey ); apache-datafusion-sqlparser-rs-0.62.0/tests/queries/tpch/18.sql000066400000000000000000000024311517524037000243410ustar00rootroot00000000000000-- 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. -- using default substitutions select c_name, c_custkey, o_orderkey, o_orderdate, o_totalprice, sum(l_quantity) from customer, orders, lineitem where o_orderkey in ( select l_orderkey from lineitem group by l_orderkey having sum(l_quantity) > 300 ) and c_custkey = o_custkey and o_orderkey = l_orderkey group by c_name, c_custkey, o_orderkey, o_orderdate, o_totalprice order by o_totalprice desc, o_orderdate; apache-datafusion-sqlparser-rs-0.62.0/tests/queries/tpch/19.sql000066400000000000000000000034471517524037000243520ustar00rootroot00000000000000-- 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. -- using default substitutions select sum(l_extendedprice* (1 - l_discount)) as revenue from lineitem, part where ( p_partkey = l_partkey and p_brand = 'Brand#12' and p_container in ('SM CASE', 'SM BOX', 'SM PACK', 'SM PKG') and l_quantity >= 1 and l_quantity <= 1 + 10 and p_size between 1 and 5 and l_shipmode in ('AIR', 'AIR REG') and l_shipinstruct = 'DELIVER IN PERSON' ) or ( p_partkey = l_partkey and p_brand = 'Brand#23' and p_container in ('MED BAG', 'MED BOX', 'MED PKG', 'MED PACK') and l_quantity >= 10 and l_quantity <= 10 + 10 and p_size between 1 and 10 and l_shipmode in ('AIR', 'AIR REG') and l_shipinstruct = 'DELIVER IN PERSON' ) or ( p_partkey = l_partkey and p_brand = 'Brand#34' and p_container in ('LG CASE', 'LG BOX', 'LG PACK', 'LG PKG') and l_quantity >= 20 and l_quantity <= 20 + 10 and p_size between 1 and 15 and l_shipmode in ('AIR', 'AIR REG') and l_shipinstruct = 'DELIVER IN PERSON' ); apache-datafusion-sqlparser-rs-0.62.0/tests/queries/tpch/2.sql000066400000000000000000000027141517524037000242560ustar00rootroot00000000000000-- 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. -- using default substitutions select s_acctbal, s_name, n_name, p_partkey, p_mfgr, s_address, s_phone, s_comment from part, supplier, partsupp, nation, region where p_partkey = ps_partkey and s_suppkey = ps_suppkey and p_size = 15 and p_type like '%BRASS' and s_nationkey = n_nationkey and n_regionkey = r_regionkey and r_name = 'EUROPE' and ps_supplycost = ( select min(ps_supplycost) from partsupp, supplier, nation, region where p_partkey = ps_partkey and s_suppkey = ps_suppkey and s_nationkey = n_nationkey and n_regionkey = r_regionkey and r_name = 'EUROPE' ) order by s_acctbal desc, n_name, s_name, p_partkey; apache-datafusion-sqlparser-rs-0.62.0/tests/queries/tpch/20.sql000066400000000000000000000026601517524037000243360ustar00rootroot00000000000000-- 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. -- using default substitutions select s_name, s_address from supplier, nation where s_suppkey in ( select ps_suppkey from partsupp where ps_partkey in ( select p_partkey from part where p_name like 'forest%' ) and ps_availqty > ( select 0.5 * sum(l_quantity) from lineitem where l_partkey = ps_partkey and l_suppkey = ps_suppkey and l_shipdate >= date '1994-01-01' and l_shipdate < date '1994-01-01' + interval '1' year ) ) and s_nationkey = n_nationkey and n_name = 'CANADA' order by s_name; apache-datafusion-sqlparser-rs-0.62.0/tests/queries/tpch/21.sql000066400000000000000000000027631517524037000243430ustar00rootroot00000000000000-- 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. -- using default substitutions select s_name, count(*) as numwait from supplier, lineitem l1, orders, nation where s_suppkey = l1.l_suppkey and o_orderkey = l1.l_orderkey and o_orderstatus = 'F' and l1.l_receiptdate > l1.l_commitdate and exists ( select * from lineitem l2 where l2.l_orderkey = l1.l_orderkey and l2.l_suppkey <> l1.l_suppkey ) and not exists ( select * from lineitem l3 where l3.l_orderkey = l1.l_orderkey and l3.l_suppkey <> l1.l_suppkey and l3.l_receiptdate > l3.l_commitdate ) and s_nationkey = n_nationkey and n_name = 'SAUDI ARABIA' group by s_name order by numwait desc, s_name; apache-datafusion-sqlparser-rs-0.62.0/tests/queries/tpch/22.sql000066400000000000000000000027541517524037000243440ustar00rootroot00000000000000-- 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. -- using default substitutions select cntrycode, count(*) as numcust, sum(c_acctbal) as totacctbal from ( select substring(c_phone from 1 for 2) as cntrycode, c_acctbal from customer where substring(c_phone from 1 for 2) in ('13', '31', '23', '29', '30', '18', '17') and c_acctbal > ( select avg(c_acctbal) from customer where c_acctbal > 0.00 and substring(c_phone from 1 for 2) in ('13', '31', '23', '29', '30', '18', '17') ) and not exists ( select * from orders where o_custkey = c_custkey ) ) as custsale group by cntrycode order by cntrycode; apache-datafusion-sqlparser-rs-0.62.0/tests/queries/tpch/3.sql000066400000000000000000000023111517524037000242500ustar00rootroot00000000000000-- 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. -- using default substitutions select l_orderkey, sum(l_extendedprice * (1 - l_discount)) as revenue, o_orderdate, o_shippriority from customer, orders, lineitem where c_mktsegment = 'BUILDING' and c_custkey = o_custkey and l_orderkey = o_orderkey and o_orderdate < date '1995-03-15' and l_shipdate > date '1995-03-15' group by l_orderkey, o_orderdate, o_shippriority order by revenue desc, o_orderdate; apache-datafusion-sqlparser-rs-0.62.0/tests/queries/tpch/4.sql000066400000000000000000000022731517524037000242600ustar00rootroot00000000000000-- 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. -- using default substitutions select o_orderpriority, count(*) as order_count from orders where o_orderdate >= date '1993-07-01' and o_orderdate < date '1993-07-01' + interval '3' month and exists ( select * from lineitem where l_orderkey = o_orderkey and l_commitdate < l_receiptdate ) group by o_orderpriority order by o_orderpriority; apache-datafusion-sqlparser-rs-0.62.0/tests/queries/tpch/5.sql000066400000000000000000000024261517524037000242610ustar00rootroot00000000000000-- 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. -- using default substitutions select n_name, sum(l_extendedprice * (1 - l_discount)) as revenue from customer, orders, lineitem, supplier, nation, region where c_custkey = o_custkey and l_orderkey = o_orderkey and l_suppkey = s_suppkey and c_nationkey = s_nationkey and s_nationkey = n_nationkey and n_regionkey = r_regionkey and r_name = 'ASIA' and o_orderdate >= date '1994-01-01' and o_orderdate < date '1994-01-01' + interval '1' year group by n_name order by revenue desc; apache-datafusion-sqlparser-rs-0.62.0/tests/queries/tpch/6.sql000066400000000000000000000021131517524037000242530ustar00rootroot00000000000000-- 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. -- using default substitutions select sum(l_extendedprice * l_discount) as revenue from lineitem where l_shipdate >= date '1994-01-01' and l_shipdate < date '1994-01-01' + interval '1' year and l_discount between .06 - 0.01 and .06 + 0.01 and l_quantity < 24; apache-datafusion-sqlparser-rs-0.62.0/tests/queries/tpch/7.sql000066400000000000000000000032111517524037000242540ustar00rootroot00000000000000-- 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. -- using default substitutions select supp_nation, cust_nation, l_year, sum(volume) as revenue from ( select n1.n_name as supp_nation, n2.n_name as cust_nation, extract(year from l_shipdate) as l_year, l_extendedprice * (1 - l_discount) as volume from supplier, lineitem, orders, customer, nation n1, nation n2 where s_suppkey = l_suppkey and o_orderkey = l_orderkey and c_custkey = o_custkey and s_nationkey = n1.n_nationkey and c_nationkey = n2.n_nationkey and ( (n1.n_name = 'FRANCE' and n2.n_name = 'GERMANY') or (n1.n_name = 'GERMANY' and n2.n_name = 'FRANCE') ) and l_shipdate between date '1995-01-01' and date '1996-12-31' ) as shipping group by supp_nation, cust_nation, l_year order by supp_nation, cust_nation, l_year; apache-datafusion-sqlparser-rs-0.62.0/tests/queries/tpch/8.sql000066400000000000000000000031641517524037000242640ustar00rootroot00000000000000-- 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. -- using default substitutions select o_year, sum(case when nation = 'BRAZIL' then volume else 0 end) / sum(volume) as mkt_share from ( select extract(year from o_orderdate) as o_year, l_extendedprice * (1 - l_discount) as volume, n2.n_name as nation from part, supplier, lineitem, orders, customer, nation n1, nation n2, region where p_partkey = l_partkey and s_suppkey = l_suppkey and l_orderkey = o_orderkey and o_custkey = c_custkey and c_nationkey = n1.n_nationkey and n1.n_regionkey = r_regionkey and r_name = 'AMERICA' and s_nationkey = n2.n_nationkey and o_orderdate between date '1995-01-01' and date '1996-12-31' and p_type = 'ECONOMY ANODIZED STEEL' ) as all_nations group by o_year order by o_year; apache-datafusion-sqlparser-rs-0.62.0/tests/queries/tpch/9.sql000066400000000000000000000026651517524037000242720ustar00rootroot00000000000000-- 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. -- using default substitutions select nation, o_year, sum(amount) as sum_profit from ( select n_name as nation, extract(year from o_orderdate) as o_year, l_extendedprice * (1 - l_discount) - ps_supplycost * l_quantity as amount from part, supplier, lineitem, partsupp, orders, nation where s_suppkey = l_suppkey and ps_suppkey = l_suppkey and ps_partkey = l_partkey and p_partkey = l_partkey and o_orderkey = l_orderkey and s_nationkey = n_nationkey and p_name like '%green%' ) as profit group by nation, o_year order by nation, o_year desc; apache-datafusion-sqlparser-rs-0.62.0/tests/sqlparser_bigquery.rs000066400000000000000000003202201517524037000252450ustar00rootroot00000000000000// 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. #[macro_use] mod test_utils; use std::ops::Deref; use sqlparser::ast::helpers::attached_token::AttachedToken; use sqlparser::ast::*; use sqlparser::dialect::{BigQueryDialect, GenericDialect}; use sqlparser::keywords::Keyword; use sqlparser::parser::{ParserError, ParserOptions}; use sqlparser::tokenizer::{Location, Span, Token, TokenWithSpan, Word}; use test_utils::*; #[test] fn parse_literal_string() { let sql = concat!( "SELECT ", // line 1, column 1 "'single', ", // line 1, column 7 r#""double", "#, // line 1, column 14 "'''triple-single''', ", // line 1, column 22 r#""""triple-double""", "#, // line 1, column 33 r#"'single\'escaped', "#, // line 1, column 43 r#"'''triple-single\'escaped''', "#, // line 1, column 55 r#"'''triple-single'unescaped''', "#, // line 1, column 68 r#""double\"escaped", "#, // line 1, column 83 r#""""triple-double\"escaped""", "#, // line 1, column 92 r#""""triple-double"unescaped""", "#, // line 1, column 105 r#""""triple-double'unescaped""", "#, // line 1, column 118 r#"'''triple-single"unescaped'''"#, // line 1, column 131 ); let dialect = TestedDialects::new_with_options( vec![Box::new(BigQueryDialect {})], ParserOptions::new().with_unescape(false), ); let select = dialect.verified_only_select(sql); assert_eq!(12, select.projection.len()); assert_eq!( &Expr::Value(Value::SingleQuotedString("single".into()).with_empty_span()), expr_from_projection(&select.projection[0]) ); assert_eq!( &Expr::Value(Value::DoubleQuotedString("double".into()).with_empty_span()), expr_from_projection(&select.projection[1]) ); assert_eq!( &Expr::Value(Value::TripleSingleQuotedString("triple-single".into()).with_empty_span()), expr_from_projection(&select.projection[2]) ); assert_eq!( &Expr::Value(Value::TripleDoubleQuotedString("triple-double".into()).with_empty_span()), expr_from_projection(&select.projection[3]) ); assert_eq!( &Expr::Value(Value::SingleQuotedString(r#"single\'escaped"#.into()).with_empty_span()), expr_from_projection(&select.projection[4]) ); assert_eq!( &Expr::Value( Value::TripleSingleQuotedString(r#"triple-single\'escaped"#.into()).with_empty_span() ), expr_from_projection(&select.projection[5]) ); assert_eq!( &Expr::Value( Value::TripleSingleQuotedString(r#"triple-single'unescaped"#.into()).with_empty_span() ), expr_from_projection(&select.projection[6]) ); assert_eq!( &Expr::Value(Value::DoubleQuotedString(r#"double\"escaped"#.to_string()).with_empty_span()), expr_from_projection(&select.projection[7]) ); assert_eq!( &Expr::Value( Value::TripleDoubleQuotedString(r#"triple-double\"escaped"#.to_string()) .with_empty_span() ), expr_from_projection(&select.projection[8]) ); assert_eq!( &Expr::Value( Value::TripleDoubleQuotedString(r#"triple-double"unescaped"#.to_string()) .with_empty_span() ), expr_from_projection(&select.projection[9]) ); assert_eq!( &Expr::Value( Value::TripleDoubleQuotedString(r#"triple-double'unescaped"#.to_string()) .with_empty_span() ), expr_from_projection(&select.projection[10]) ); assert_eq!( &Expr::Value( Value::TripleSingleQuotedString(r#"triple-single"unescaped"#.to_string()) .with_empty_span() ), expr_from_projection(&select.projection[11]) ); } #[test] fn parse_byte_literal() { let sql = concat!( "SELECT ", // line 1, column 1 "B'abc', ", // line 1, column 8 r#"B"abc", "#, // line 1, column 15 r#"B'f\(abc,(.*),def\)', "#, // line 1, column 22 r#"B"f\(abc,(.*),def\)", "#, // line 1, column 42 r#"B'''abc''', "#, // line 1, column 62 r#"B"""abc""""#, // line 1, column 74 ); let stmt = bigquery().verified_stmt(sql); if let Statement::Query(query) = stmt { if let SetExpr::Select(select) = *query.body { assert_eq!(6, select.projection.len()); assert_eq!( &Expr::Value( Value::SingleQuotedByteStringLiteral("abc".to_string()).with_empty_span() ), expr_from_projection(&select.projection[0]) ); assert_eq!( &Expr::Value( Value::DoubleQuotedByteStringLiteral("abc".to_string()).with_empty_span() ), expr_from_projection(&select.projection[1]) ); assert_eq!( &Expr::Value( Value::SingleQuotedByteStringLiteral(r"f\(abc,(.*),def\)".to_string()) .with_empty_span() ), expr_from_projection(&select.projection[2]) ); assert_eq!( &Expr::Value( Value::DoubleQuotedByteStringLiteral(r"f\(abc,(.*),def\)".to_string()) .with_empty_span() ), expr_from_projection(&select.projection[3]) ); assert_eq!( &Expr::Value( Value::TripleSingleQuotedByteStringLiteral(r"abc".to_string()) .with_empty_span() ), expr_from_projection(&select.projection[4]) ); assert_eq!( &Expr::Value( Value::TripleDoubleQuotedByteStringLiteral(r"abc".to_string()) .with_empty_span() ), expr_from_projection(&select.projection[5]) ); } } else { panic!("invalid query"); } bigquery().one_statement_parses_to( r#"SELECT b'123', b"123", b'''123''', b"""123""""#, r#"SELECT B'123', B"123", B'''123''', B"""123""""#, ); } #[test] fn parse_raw_literal() { let sql = concat!( "SELECT ", // line 1, column 1 "R'abc', ", // line 1, column 8 r#"R"abc", "#, // line 1, column 15 r#"R'f\(abc,(.*),def\)', "#, // line 1, column 22 r#"R"f\(abc,(.*),def\)", "#, // line 1, column 42 r#"R'''abc''', "#, // line 1, column 62 r#"R"""abc""""#, // line 1, column 74 ); let stmt = bigquery().verified_stmt(sql); if let Statement::Query(query) = stmt { if let SetExpr::Select(select) = *query.body { assert_eq!(6, select.projection.len()); assert_eq!( &Expr::Value( Value::SingleQuotedRawStringLiteral("abc".to_string()).with_empty_span() ), expr_from_projection(&select.projection[0]) ); assert_eq!( &Expr::Value( Value::DoubleQuotedRawStringLiteral("abc".to_string()).with_empty_span() ), expr_from_projection(&select.projection[1]) ); assert_eq!( &Expr::Value( Value::SingleQuotedRawStringLiteral(r"f\(abc,(.*),def\)".to_string()) .with_empty_span() ), expr_from_projection(&select.projection[2]) ); assert_eq!( &Expr::Value( Value::DoubleQuotedRawStringLiteral(r"f\(abc,(.*),def\)".to_string()) .with_empty_span() ), expr_from_projection(&select.projection[3]) ); assert_eq!( &Expr::Value( Value::TripleSingleQuotedRawStringLiteral(r"abc".to_string()).with_empty_span() ), expr_from_projection(&select.projection[4]) ); assert_eq!( &Expr::Value( Value::TripleDoubleQuotedRawStringLiteral(r"abc".to_string()).with_empty_span() ), expr_from_projection(&select.projection[5]) ); } } else { panic!("invalid query"); } bigquery().one_statement_parses_to( r#"SELECT r'123', r"123", r'''123''', r"""123""""#, r#"SELECT R'123', R"123", R'''123''', R"""123""""#, ); } #[test] fn parse_big_query_non_reserved_column_alias() { let sql = r#"SELECT OFFSET, EXPLAIN, ANALYZE, SORT, TOP, VIEW FROM T"#; bigquery().verified_stmt(sql); let sql = r#"SELECT 1 AS OFFSET, 2 AS EXPLAIN, 3 AS ANALYZE FROM T"#; bigquery().verified_stmt(sql); } #[test] fn parse_at_at_identifier() { bigquery().verified_stmt("SELECT @@error.stack_trace, @@error.message"); } #[test] fn parse_begin() { let sql = r#"BEGIN SELECT 1; EXCEPTION WHEN ERROR THEN SELECT 2; RAISE USING MESSAGE = FORMAT('ERR: %s', 'Bad'); END"#; let Statement::StartTransaction { statements, exception, has_end_keyword, .. } = bigquery().verified_stmt(sql) else { unreachable!(); }; assert_eq!(1, statements.len()); assert!(exception.is_some()); let exception = exception.unwrap(); assert_eq!(1, exception.len()); assert!(has_end_keyword); bigquery().verified_stmt( "BEGIN SELECT 1; SELECT 2; EXCEPTION WHEN ERROR THEN SELECT 2; SELECT 4; END", ); bigquery() .verified_stmt("BEGIN SELECT 1; EXCEPTION WHEN ERROR THEN SELECT @@error.stack_trace; END"); bigquery().verified_stmt("BEGIN EXCEPTION WHEN ERROR THEN SELECT 2; END"); bigquery().verified_stmt("BEGIN SELECT 1; SELECT 2; EXCEPTION WHEN ERROR THEN END"); bigquery().verified_stmt("BEGIN EXCEPTION WHEN ERROR THEN END"); bigquery().verified_stmt("BEGIN SELECT 1; SELECT 2; END"); bigquery().verified_stmt("BEGIN END"); assert_eq!( bigquery() .parse_sql_statements("BEGIN SELECT 1; SELECT 2 END") .unwrap_err(), ParserError::ParserError("Expected: ;, found: END".to_string()) ); assert_eq!( bigquery() .parse_sql_statements("BEGIN SELECT 1; EXCEPTION WHEN ERROR THEN SELECT 2 END") .unwrap_err(), ParserError::ParserError("Expected: ;, found: END".to_string()) ); } #[test] fn parse_delete_statement() { let sql = "DELETE \"table\" WHERE 1"; match bigquery_and_generic().verified_stmt(sql) { Statement::Delete(Delete { from: FromTable::WithoutKeyword(from), .. }) => { assert_eq!( table_from_name(ObjectName::from(vec![Ident::with_quote('"', "table")])), from[0].relation ); } _ => unreachable!(), } } #[test] fn parse_create_view_with_options() { let sql = concat!( "CREATE VIEW myproject.mydataset.newview ", r#"(name, age OPTIONS(description = "field age")) "#, r#"OPTIONS(expiration_timestamp = TIMESTAMP_ADD(CURRENT_TIMESTAMP(), INTERVAL 48 HOUR), "#, r#"friendly_name = "newview", description = "a view that expires in 2 days", labels = [("org_unit", "development")]) "#, "AS SELECT column_1, column_2, column_3 FROM myproject.mydataset.mytable", ); match bigquery().verified_stmt(sql) { Statement::CreateView(CreateView { name, query, options, columns, .. }) => { assert_eq!( name, ObjectName::from(vec![ "myproject".into(), "mydataset".into(), "newview".into() ]) ); assert_eq!( vec![ ViewColumnDef { name: Ident::new("name"), data_type: None, options: None, }, ViewColumnDef { name: Ident::new("age"), data_type: None, options: Some(ColumnOptions::CommaSeparated(vec![ColumnOption::Options( vec![SqlOption::KeyValue { key: Ident::new("description"), value: Expr::Value( Value::DoubleQuotedString("field age".to_string()).with_span( Span::new(Location::new(1, 42), Location::new(1, 52)) ) ), }] )])), }, ], columns ); assert_eq!( "SELECT column_1, column_2, column_3 FROM myproject.mydataset.mytable", query.to_string() ); assert_eq!( r#"OPTIONS(expiration_timestamp = TIMESTAMP_ADD(CURRENT_TIMESTAMP(), INTERVAL 48 HOUR), friendly_name = "newview", description = "a view that expires in 2 days", labels = [("org_unit", "development")])"#, options.to_string() ); let CreateTableOptions::Options(options) = options else { unreachable!() }; assert_eq!( &SqlOption::KeyValue { key: Ident::new("description"), value: Expr::Value( Value::DoubleQuotedString("a view that expires in 2 days".to_string()) .with_empty_span() ), }, &options[2], ); } _ => unreachable!(), } } #[test] fn parse_create_view_if_not_exists() { let sql = "CREATE VIEW IF NOT EXISTS mydataset.newview AS SELECT foo FROM bar"; match bigquery().verified_stmt(sql) { Statement::CreateView(CreateView { name, columns, query, or_replace, materialized, options, cluster_by, comment, with_no_schema_binding: late_binding, if_not_exists, temporary, .. }) => { assert_eq!("mydataset.newview", name.to_string()); assert_eq!(Vec::::new(), columns); assert_eq!("SELECT foo FROM bar", query.to_string()); assert!(!materialized); assert!(!or_replace); assert_eq!(options, CreateTableOptions::None); assert_eq!(cluster_by, vec![]); assert!(comment.is_none()); assert!(!late_binding); assert!(if_not_exists); assert!(!temporary); } _ => unreachable!(), } } #[test] fn parse_create_view_with_unquoted_hyphen() { let sql = "CREATE VIEW IF NOT EXISTS my-pro-ject.mydataset.myview AS SELECT 1"; match bigquery().verified_stmt(sql) { Statement::CreateView(CreateView { name, query, if_not_exists, .. }) => { assert_eq!("my-pro-ject.mydataset.myview", name.to_string()); assert_eq!("SELECT 1", query.to_string()); assert!(if_not_exists); } _ => unreachable!(), } } #[test] fn parse_create_table_with_unquoted_hyphen() { let sql = "CREATE TABLE my-pro-ject.mydataset.mytable (x INT64)"; match bigquery().verified_stmt(sql) { Statement::CreateTable(CreateTable { name, columns, .. }) => { assert_eq!( name, ObjectName::from(vec![ "my-pro-ject".into(), "mydataset".into(), "mytable".into() ]) ); assert_eq!( vec![ColumnDef { name: Ident::new("x"), data_type: DataType::Int64, options: vec![] },], columns ); } _ => unreachable!(), } } #[test] fn parse_create_table_with_options() { let sql = concat!( "CREATE TABLE mydataset.newtable ", r#"(x INT64 NOT NULL OPTIONS(description = "field x"), "#, r#"y BOOL OPTIONS(description = "field y")) "#, "PARTITION BY _PARTITIONDATE ", "CLUSTER BY userid, age ", r#"OPTIONS(partition_expiration_days = 1, description = "table option description")"# ); match bigquery().verified_stmt(sql) { Statement::CreateTable(CreateTable { name, columns, partition_by, cluster_by, table_options, .. }) => { assert_eq!( name, ObjectName::from(vec!["mydataset".into(), "newtable".into()]) ); assert_eq!( vec![ ColumnDef { name: Ident::new("x"), data_type: DataType::Int64, options: vec![ ColumnOptionDef { name: None, option: ColumnOption::NotNull, }, ColumnOptionDef { name: None, option: ColumnOption::Options(vec![SqlOption::KeyValue { key: Ident::new("description"), value: Expr::Value( Value::DoubleQuotedString("field x".to_string()).with_span( Span::new(Location::new(1, 42), Location::new(1, 52)) ) ), },]) }, ] }, ColumnDef { name: Ident::new("y"), data_type: DataType::Bool, options: vec![ColumnOptionDef { name: None, option: ColumnOption::Options(vec![SqlOption::KeyValue { key: Ident::new("description"), value: Expr::Value( Value::DoubleQuotedString("field y".to_string()).with_span( Span::new(Location::new(1, 42), Location::new(1, 52)) ) ), },]) }] }, ], columns ); assert_eq!( ( Some(Box::new(Expr::Identifier(Ident::new("_PARTITIONDATE")))), Some(WrappedCollection::NoWrapping(vec![ Expr::Identifier(Ident::new("userid")), Expr::Identifier(Ident::new("age")), ])), CreateTableOptions::Options(vec![ SqlOption::KeyValue { key: Ident::new("partition_expiration_days"), value: Expr::Value( number("1").with_span(Span::new( Location::new(1, 42), Location::new(1, 43) )) ), }, SqlOption::KeyValue { key: Ident::new("description"), value: Expr::Value( Value::DoubleQuotedString("table option description".to_string()) .with_span(Span::new( Location::new(1, 42), Location::new(1, 52) )) ), }, ]) ), (partition_by, cluster_by, table_options) ) } _ => unreachable!(), } let sql = concat!( "CREATE TABLE mydataset.newtable ", r#"(x INT64 NOT NULL OPTIONS(description = "field x"), "#, r#"y BOOL OPTIONS(description = "field y")) "#, "CLUSTER BY userid ", r#"OPTIONS(partition_expiration_days = 1, "#, r#"description = "table option description")"# ); bigquery().verified_stmt(sql); let sql = "CREATE TABLE foo (x INT64) OPTIONS()"; bigquery().verified_stmt(sql); let sql = "CREATE TABLE db.schema.test (x INT64 OPTIONS(description = 'An optional INTEGER field')) OPTIONS()"; bigquery().verified_stmt(sql); } #[test] fn parse_create_external_table_with_options() { bigquery().verified_stmt( "CREATE EXTERNAL TABLE dataset_id.table1 (hvr_tx_seq STRING) OPTIONS(format = 'CSV')", ); bigquery().verified_stmt( "CREATE EXTERNAL TABLE dataset_id.table1 (hvr_tx_seq STRING) OPTIONS(format = 'CSV', allow_quoted_newlines = true, encoding = 'UTF8')", ); } #[test] fn parse_nested_data_types() { let sql = "CREATE TABLE table (x STRUCT, b BYTES(42)>, y ARRAY>)"; match bigquery_and_generic().one_statement_parses_to(sql, sql) { Statement::CreateTable(CreateTable { name, columns, .. }) => { assert_eq!(name, ObjectName::from(vec!["table".into()])); assert_eq!( columns, vec![ ColumnDef { name: Ident::new("x"), data_type: DataType::Struct( vec![ StructField { field_name: Some("a".into()), field_type: DataType::Array(ArrayElemTypeDef::AngleBracket( Box::new(DataType::Int64,) )), options: None, }, StructField { field_name: Some("b".into()), field_type: DataType::Bytes(Some(42)), options: None, }, ], StructBracketKind::AngleBrackets ), options: vec![], }, ColumnDef { name: Ident::new("y"), data_type: DataType::Array(ArrayElemTypeDef::AngleBracket(Box::new( DataType::Struct( vec![StructField { field_name: None, field_type: DataType::Int64, options: None, }], StructBracketKind::AngleBrackets ), ))), options: vec![], }, ] ); } _ => unreachable!(), } } #[test] fn parse_tuple_struct_literal() { // tuple syntax: https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types#tuple_syntax // syntax: (expr1, expr2 [, ... ]) let sql = "SELECT (1, 2, 3), (1, 1.0, '123', true)"; // line 1, column 1 let select = bigquery().verified_only_select(sql); assert_eq!(2, select.projection.len()); assert_eq!( &Expr::Tuple(vec![ Expr::value(number("1")), Expr::value(number("2")), Expr::value(number("3")), ]), expr_from_projection(&select.projection[0]) ); assert_eq!( &Expr::Tuple(vec![ Expr::value(number("1")), Expr::value(number("1.0")), Expr::Value(Value::SingleQuotedString("123".into()).with_empty_span()), Expr::Value(Value::Boolean(true).with_empty_span()) ]), expr_from_projection(&select.projection[1]) ); } #[test] fn parse_typeless_struct_syntax() { // typeless struct syntax https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types#typeless_struct_syntax // syntax: STRUCT( expr1 [AS field_name] [, ... ]) let sql = "SELECT STRUCT(1, 2, 3), STRUCT('abc'), STRUCT(1, t.str_col), STRUCT(1 AS a, 'abc' AS b), STRUCT(str_col AS abc)"; let select = bigquery_and_generic().verified_only_select(sql); assert_eq!(5, select.projection.len()); assert_eq!( &Expr::Struct { values: vec![ Expr::value(number("1")), Expr::value(number("2")), Expr::value(number("3")), ], fields: Default::default() }, expr_from_projection(&select.projection[0]) ); assert_eq!( &Expr::Struct { values: vec![Expr::Value( Value::SingleQuotedString("abc".into()).with_empty_span() )], fields: Default::default() }, expr_from_projection(&select.projection[1]) ); assert_eq!( &Expr::Struct { values: vec![ Expr::value(number("1")), Expr::CompoundIdentifier(vec![Ident::from("t"), Ident::from("str_col")]), ], fields: Default::default() }, expr_from_projection(&select.projection[2]) ); assert_eq!( &Expr::Struct { values: vec![ Expr::Named { expr: Expr::value(number("1")).into(), name: Ident::from("a") }, Expr::Named { expr: Expr::Value(Value::SingleQuotedString("abc".into()).with_empty_span()) .into(), name: Ident::from("b") }, ], fields: Default::default() }, expr_from_projection(&select.projection[3]) ); assert_eq!( &Expr::Struct { values: vec![Expr::Named { expr: Expr::Identifier(Ident::from("str_col")).into(), name: Ident::from("abc") }], fields: Default::default() }, expr_from_projection(&select.projection[4]) ); } #[test] fn parse_typed_struct_syntax_bigquery() { // typed struct syntax https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types#typed_struct_syntax // syntax: STRUCT<[field_name] field_type, ...>( expr1 [, ... ]) let sql = r#"SELECT STRUCT(5), STRUCT(1, t.str_col), STRUCT, str STRUCT>(nested_col)"#; let select = bigquery().verified_only_select(sql); assert_eq!(3, select.projection.len()); assert_eq!( &Expr::Struct { values: vec![Expr::value(number("5"))], fields: vec![StructField { field_name: None, field_type: DataType::Int64, options: None, }] }, expr_from_projection(&select.projection[0]) ); assert_eq!( &Expr::Struct { values: vec![ Expr::value(number("1")), Expr::CompoundIdentifier(vec![ Ident { value: "t".into(), quote_style: None, span: Span::empty(), }, Ident { value: "str_col".into(), quote_style: None, span: Span::empty(), }, ]), ], fields: vec![ StructField { field_name: Some(Ident { value: "x".into(), quote_style: None, span: Span::empty(), }), field_type: DataType::Int64, options: None, }, StructField { field_name: Some(Ident { value: "y".into(), quote_style: None, span: Span::empty(), }), field_type: DataType::String(None), options: None, }, ] }, expr_from_projection(&select.projection[1]) ); assert_eq!( &Expr::Struct { values: vec![Expr::Identifier(Ident { value: "nested_col".into(), quote_style: None, span: Span::empty(), })], fields: vec![ StructField { field_name: Some("arr".into()), field_type: DataType::Array(ArrayElemTypeDef::AngleBracket(Box::new( DataType::Float64 ))), options: None, }, StructField { field_name: Some("str".into()), field_type: DataType::Struct( vec![StructField { field_name: None, field_type: DataType::Bool, options: None, }], StructBracketKind::AngleBrackets ), options: None, }, ] }, expr_from_projection(&select.projection[2]) ); let sql = r#"SELECT STRUCT>(nested_col)"#; let select = bigquery().verified_only_select(sql); assert_eq!(1, select.projection.len()); assert_eq!( &Expr::Struct { values: vec![Expr::Identifier(Ident { value: "nested_col".into(), quote_style: None, span: Span::empty(), })], fields: vec![ StructField { field_name: Some("x".into()), field_type: DataType::Struct( Default::default(), StructBracketKind::AngleBrackets ), options: None, }, StructField { field_name: Some("y".into()), field_type: DataType::Array(ArrayElemTypeDef::AngleBracket(Box::new( DataType::Struct(Default::default(), StructBracketKind::AngleBrackets) ))), options: None, }, ] }, expr_from_projection(&select.projection[0]) ); let sql = r#"SELECT STRUCT(true), STRUCT(B'abc')"#; let select = bigquery().verified_only_select(sql); assert_eq!(2, select.projection.len()); assert_eq!( &Expr::Struct { values: vec![Expr::Value(Value::Boolean(true).with_empty_span())], fields: vec![StructField { field_name: None, field_type: DataType::Bool, options: None, }] }, expr_from_projection(&select.projection[0]) ); assert_eq!( &Expr::Struct { values: vec![Expr::Value( Value::SingleQuotedByteStringLiteral("abc".into()).with_empty_span() )], fields: vec![StructField { field_name: None, field_type: DataType::Bytes(Some(42)), options: None, }] }, expr_from_projection(&select.projection[1]) ); let sql = r#"SELECT STRUCT("2011-05-05"), STRUCT(DATETIME '1999-01-01 01:23:34.45'), STRUCT(5.0), STRUCT(1)"#; let select = bigquery().verified_only_select(sql); assert_eq!(4, select.projection.len()); assert_eq!( &Expr::Struct { values: vec![Expr::Value( Value::DoubleQuotedString("2011-05-05".into()).with_empty_span() )], fields: vec![StructField { field_name: None, field_type: DataType::Date, options: None, }] }, expr_from_projection(&select.projection[0]) ); assert_eq!( &Expr::Struct { values: vec![Expr::TypedString(TypedString { data_type: DataType::Datetime(None), value: ValueWithSpan { value: Value::SingleQuotedString("1999-01-01 01:23:34.45".into()), span: Span::empty(), }, uses_odbc_syntax: false })], fields: vec![StructField { field_name: None, field_type: DataType::Datetime(None), options: None, }] }, expr_from_projection(&select.projection[1]) ); assert_eq!( &Expr::Struct { values: vec![Expr::value(number("5.0"))], fields: vec![StructField { field_name: None, field_type: DataType::Float64, options: None, }] }, expr_from_projection(&select.projection[2]) ); assert_eq!( &Expr::Struct { values: vec![Expr::value(number("1"))], fields: vec![StructField { field_name: None, field_type: DataType::Int64, options: None, }] }, expr_from_projection(&select.projection[3]) ); let sql = r#"SELECT STRUCT(INTERVAL '2' HOUR), STRUCT(JSON '{"class" : {"students" : [{"name" : "Jane"}]}}')"#; let select = bigquery().verified_only_select(sql); assert_eq!(2, select.projection.len()); assert_eq!( &Expr::Struct { values: vec![Expr::Interval(Interval { value: Box::new(Expr::Value( Value::SingleQuotedString("2".into()).with_empty_span() )), leading_field: Some(DateTimeField::Hour), leading_precision: None, last_field: None, fractional_seconds_precision: None })], fields: vec![StructField { field_name: None, field_type: DataType::Interval { fields: None, precision: None }, options: None, }] }, expr_from_projection(&select.projection[0]) ); assert_eq!( &Expr::Struct { values: vec![Expr::TypedString(TypedString { data_type: DataType::JSON, value: ValueWithSpan { value: Value::SingleQuotedString( r#"{"class" : {"students" : [{"name" : "Jane"}]}}"#.into() ), span: Span::empty(), }, uses_odbc_syntax: false })], fields: vec![StructField { field_name: None, field_type: DataType::JSON, options: None, }] }, expr_from_projection(&select.projection[1]) ); let sql = r#"SELECT STRUCT("foo"), STRUCT(TIMESTAMP '2008-12-25 15:30:00 America/Los_Angeles'), STRUCT, ", "f1 STRUCT<", "a STRING OPTIONS(description = 'This is a string', type = 'string'), ", "b INT64", "> OPTIONS(description = 'This is a struct field')", ")", )); } #[test] fn test_struct_trailing_and_nested_bracket() { bigquery().verified_stmt(concat!( "CREATE TABLE my_table (", "f0 STRING, ", "f1 STRUCT>, ", "f2 STRING", ")", )); // More complex nested structs bigquery().verified_stmt(concat!( "CREATE TABLE my_table (", "f0 STRING, ", "f1 STRUCT>>, ", "f2 STRUCT>>>, ", "f3 STRUCT>", ")", )); // Bad case with missing closing bracket assert_eq!( ParserError::ParserError("Expected: >, found: )".to_owned()), bigquery() .parse_sql_statements("CREATE TABLE my_table(f1 STRUCT after parsing data type STRUCT)".to_owned() ), bigquery() .parse_sql_statements("CREATE TABLE my_table(f1 STRUCT>)") .unwrap_err() ); // Base case with redundant closing bracket in nested struct assert_eq!( ParserError::ParserError( "Expected: ',' or ')' after column definition, found: >".to_owned() ), bigquery() .parse_sql_statements("CREATE TABLE my_table(f1 STRUCT>>, c INT64)") .unwrap_err() ); let sql = "SELECT STRUCT>(NULL)"; assert_eq!( bigquery_and_generic() .parse_sql_statements(sql) .unwrap_err(), ParserError::ParserError("unmatched > in STRUCT literal".to_string()) ); let sql = "SELECT STRUCT>>(NULL)"; assert_eq!( bigquery_and_generic() .parse_sql_statements(sql) .unwrap_err(), ParserError::ParserError("Expected: (, found: >".to_string()) ); let sql = "CREATE TABLE table (x STRUCT>>)"; assert_eq!( bigquery_and_generic() .parse_sql_statements(sql) .unwrap_err(), ParserError::ParserError( "Expected: ',' or ')' after column definition, found: >".to_string() ) ); } #[test] fn test_export_data() { let stmt = bigquery().verified_stmt(concat!( "EXPORT DATA OPTIONS(", "uri = 'gs://bucket/folder/*', ", "format = 'PARQUET', ", "overwrite = true", ") AS ", "SELECT field1, field2 FROM mydataset.table1 ORDER BY field1 LIMIT 10", )); assert_eq!( stmt, Statement::ExportData(ExportData { options: vec![ SqlOption::KeyValue { key: Ident::new("uri"), value: Expr::Value( Value::SingleQuotedString("gs://bucket/folder/*".to_owned()) .with_empty_span() ), }, SqlOption::KeyValue { key: Ident::new("format"), value: Expr::Value( Value::SingleQuotedString("PARQUET".to_owned()).with_empty_span() ), }, SqlOption::KeyValue { key: Ident::new("overwrite"), value: Expr::Value(Value::Boolean(true).with_empty_span()), }, ], connection: None, query: Box::new(Query { with: None, body: Box::new(SetExpr::Select(Box::new(Select { select_token: AttachedToken(TokenWithSpan::new( Token::Word(Word { value: "SELECT".to_string(), quote_style: None, keyword: Keyword::SELECT, }), Span::empty() )), optimizer_hints: vec![], distinct: None, select_modifiers: None, top: None, top_before_distinct: false, projection: vec![ SelectItem::UnnamedExpr(Expr::Identifier(Ident::new("field1"))), SelectItem::UnnamedExpr(Expr::Identifier(Ident::new("field2"))), ], exclude: None, into: None, from: vec![TableWithJoins { relation: table_from_name(ObjectName::from(vec![ Ident::new("mydataset"), Ident::new("table1") ])), joins: vec![], }], lateral_views: vec![], prewhere: None, selection: None, group_by: GroupByExpr::Expressions(vec![], vec![]), cluster_by: vec![], distribute_by: vec![], sort_by: vec![], having: None, named_window: vec![], qualify: None, window_before_qualify: false, value_table_mode: None, connect_by: vec![], flavor: SelectFlavor::Standard, }))), order_by: Some(OrderBy { kind: OrderByKind::Expressions(vec![OrderByExpr { expr: Expr::Identifier(Ident::new("field1")), options: OrderByOptions { asc: None, nulls_first: None, }, with_fill: None, },]), interpolate: None, }), limit_clause: Some(LimitClause::LimitOffset { limit: Some(Expr::Value(number("10").with_empty_span())), offset: None, limit_by: vec![], }), fetch: None, locks: vec![], for_clause: None, settings: None, format_clause: None, pipe_operators: vec![], }) }) ); let stmt = bigquery().verified_stmt(concat!( "EXPORT DATA WITH CONNECTION myconnection.myproject.us OPTIONS(", "uri = 'gs://bucket/folder/*', ", "format = 'PARQUET', ", "overwrite = true", ") AS ", "SELECT field1, field2 FROM mydataset.table1 ORDER BY field1 LIMIT 10", )); assert_eq!( stmt, Statement::ExportData(ExportData { options: vec![ SqlOption::KeyValue { key: Ident::new("uri"), value: Expr::Value( Value::SingleQuotedString("gs://bucket/folder/*".to_owned()) .with_empty_span() ), }, SqlOption::KeyValue { key: Ident::new("format"), value: Expr::Value( Value::SingleQuotedString("PARQUET".to_owned()).with_empty_span() ), }, SqlOption::KeyValue { key: Ident::new("overwrite"), value: Expr::Value(Value::Boolean(true).with_empty_span()), }, ], connection: Some(ObjectName::from(vec![ Ident::new("myconnection"), Ident::new("myproject"), Ident::new("us") ])), query: Box::new(Query { with: None, body: Box::new(SetExpr::Select(Box::new(Select { select_token: AttachedToken(TokenWithSpan::new( Token::Word(Word { value: "SELECT".to_string(), quote_style: None, keyword: Keyword::SELECT, }), Span::empty() )), optimizer_hints: vec![], distinct: None, select_modifiers: None, top: None, top_before_distinct: false, projection: vec![ SelectItem::UnnamedExpr(Expr::Identifier(Ident::new("field1"))), SelectItem::UnnamedExpr(Expr::Identifier(Ident::new("field2"))), ], exclude: None, into: None, from: vec![TableWithJoins { relation: table_from_name(ObjectName::from(vec![ Ident::new("mydataset"), Ident::new("table1") ])), joins: vec![], }], lateral_views: vec![], prewhere: None, selection: None, group_by: GroupByExpr::Expressions(vec![], vec![]), cluster_by: vec![], distribute_by: vec![], sort_by: vec![], having: None, named_window: vec![], qualify: None, window_before_qualify: false, value_table_mode: None, connect_by: vec![], flavor: SelectFlavor::Standard, }))), order_by: Some(OrderBy { kind: OrderByKind::Expressions(vec![OrderByExpr { expr: Expr::Identifier(Ident::new("field1")), options: OrderByOptions { asc: None, nulls_first: None, }, with_fill: None, },]), interpolate: None, }), limit_clause: Some(LimitClause::LimitOffset { limit: Some(Expr::Value(number("10").with_empty_span())), offset: None, limit_by: vec![], }), fetch: None, locks: vec![], for_clause: None, settings: None, format_clause: None, pipe_operators: vec![], }) }) ); // at least one option (uri) is required let err = bigquery() .parse_sql_statements(concat!( "EXPORT DATA OPTIONS() AS ", "SELECT field1, field2 FROM mydataset.table1 ORDER BY field1 LIMIT 10", )) .unwrap_err(); assert_eq!( err.to_string(), "sql parser error: Expected: identifier, found: )" ); let err = bigquery() .parse_sql_statements( "EXPORT DATA AS SELECT field1, field2 FROM mydataset.table1 ORDER BY field1 LIMIT 10", ) .unwrap_err(); assert_eq!( err.to_string(), "sql parser error: Expected: OPTIONS, found: AS" ); } #[test] fn test_begin_transaction() { bigquery().verified_stmt("BEGIN TRANSACTION"); } #[test] fn test_begin_statement() { bigquery().verified_stmt("BEGIN"); } #[test] fn test_alter_schema() { bigquery_and_generic().verified_stmt("ALTER SCHEMA mydataset SET DEFAULT COLLATE 'und:ci'"); bigquery_and_generic().verified_stmt("ALTER SCHEMA mydataset ADD REPLICA 'us'"); bigquery_and_generic() .verified_stmt("ALTER SCHEMA mydataset ADD REPLICA 'us' OPTIONS (location = 'us')"); bigquery_and_generic().verified_stmt("ALTER SCHEMA mydataset DROP REPLICA 'us'"); bigquery_and_generic().verified_stmt("ALTER SCHEMA mydataset SET OPTIONS (location = 'us')"); bigquery_and_generic() .verified_stmt("ALTER SCHEMA IF EXISTS mydataset SET OPTIONS (location = 'us')"); } #[test] fn test_create_snapshot_table() { bigquery_and_generic() .verified_stmt("CREATE SNAPSHOT TABLE dataset_id.table1 CLONE dataset_id.table2"); bigquery().verified_stmt( "CREATE SNAPSHOT TABLE IF NOT EXISTS dataset_id.table1 CLONE dataset_id.table2", ); bigquery().verified_stmt( "CREATE SNAPSHOT TABLE dataset_id.table1 CLONE dataset_id.table2 FOR SYSTEM_TIME AS OF TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 1 HOUR)", ); bigquery().verified_stmt( "CREATE SNAPSHOT TABLE dataset_id.table1 CLONE dataset_id.table2 OPTIONS(expiration_timestamp = TIMESTAMP '2025-01-01 00:00:00 UTC', friendly_name = 'my_table')", ); bigquery().verified_stmt( "CREATE SNAPSHOT TABLE IF NOT EXISTS dataset_id.table1 CLONE dataset_id.table2 FOR SYSTEM_TIME AS OF TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 1 HOUR) OPTIONS(expiration_timestamp = TIMESTAMP '2025-01-01 00:00:00 UTC')", ); } apache-datafusion-sqlparser-rs-0.62.0/tests/sqlparser_clickhouse.rs000066400000000000000000002111311517524037000255470ustar00rootroot00000000000000// 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. #![warn(clippy::all)] //! Test SQL syntax specific to ClickHouse. #[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::SelectItem::UnnamedExpr; use sqlparser::ast::TableFactor::Table; use sqlparser::ast::Value::Boolean; use sqlparser::ast::*; use sqlparser::dialect::ClickHouseDialect; use sqlparser::dialect::GenericDialect; use sqlparser::parser::ParserError::ParserError; #[test] fn parse_map_access_expr() { let sql = r#"SELECT string_values[indexOf(string_names, 'endpoint')] FROM foos WHERE id = 'test' AND string_value[indexOf(string_name, 'app')] <> 'foo'"#; let select = clickhouse().verified_only_select(sql); assert_eq!( Select { select_token: AttachedToken::empty(), optimizer_hints: vec![], distinct: None, select_modifiers: None, top: None, top_before_distinct: false, projection: vec![UnnamedExpr(Expr::CompoundFieldAccess { root: Box::new(Identifier(Ident { value: "string_values".to_string(), quote_style: None, span: Span::empty(), })), access_chain: vec![AccessExpr::Subscript(Subscript::Index { index: call( "indexOf", [ Expr::Identifier(Ident::new("string_names")), Expr::value(Value::SingleQuotedString("endpoint".to_string())) ] ), })], })], exclude: None, into: None, from: vec![TableWithJoins { relation: table_from_name(ObjectName::from(vec![Ident::new("foos")])), joins: vec![], }], lateral_views: vec![], prewhere: None, selection: Some(BinaryOp { left: Box::new(BinaryOp { left: Box::new(Identifier(Ident::new("id"))), op: BinaryOperator::Eq, 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( "indexOf", [ Expr::Identifier(Ident::new("string_name")), Expr::value(Value::SingleQuotedString("app".to_string())) ] ), })], }), op: BinaryOperator::NotEq, right: Box::new(Expr::value(Value::SingleQuotedString("foo".to_string()))), }), }), group_by: GroupByExpr::Expressions(vec![], vec![]), cluster_by: vec![], distribute_by: vec![], sort_by: vec![], having: None, named_window: vec![], window_before_qualify: false, qualify: None, value_table_mode: None, connect_by: vec![], flavor: SelectFlavor::Standard, }, select ); } #[test] fn parse_array_expr() { let sql = "SELECT ['1', '2'] FROM test"; let select = clickhouse().verified_only_select(sql); assert_eq!( &Expr::Array(Array { elem: vec![ Expr::value(Value::SingleQuotedString("1".to_string())), Expr::value(Value::SingleQuotedString("2".to_string())), ], named: false, }), expr_from_projection(only(&select.projection)) ) } #[test] fn parse_array_fn() { let sql = "SELECT array(x1, x2) FROM foo"; let select = clickhouse().verified_only_select(sql); assert_eq!( &call( "array", [ Expr::Identifier(Ident::new("x1")), Expr::Identifier(Ident::new("x2")) ] ), expr_from_projection(only(&select.projection)) ); } #[test] fn parse_kill() { let stmt = clickhouse().verified_stmt("KILL MUTATION 5"); assert_eq!( stmt, Statement::Kill { modifier: Some(KillType::Mutation), id: 5, } ); } #[test] fn parse_delimited_identifiers() { // check that quoted identifiers in any position remain quoted after serialization let select = clickhouse().verified_only_select( r#"SELECT "alias"."bar baz", "myfun"(), "simple id" AS "column alias" FROM "a table" AS "alias""#, ); // check FROM match only(select.from).relation { TableFactor::Table { name, alias, args, with_hints, version, .. } => { assert_eq!( ObjectName::from(vec![Ident::with_quote('"', "a table")]), name ); assert_eq!(Ident::with_quote('"', "alias"), alias.unwrap().name); assert!(args.is_none()); assert!(with_hints.is_empty()); assert!(version.is_none()); } _ => panic!("Expecting TableFactor::Table"), } // check SELECT assert_eq!(3, select.projection.len()); assert_eq!( &Expr::CompoundIdentifier(vec![ Ident::with_quote('"', "alias"), Ident::with_quote('"', "bar baz"), ]), expr_from_projection(&select.projection[0]), ); assert_eq!( &Expr::Function(Function { name: ObjectName::from(vec![Ident::with_quote('"', "myfun")]), uses_odbc_syntax: false, parameters: FunctionArguments::None, args: FunctionArguments::List(FunctionArgumentList { duplicate_treatment: None, args: vec![], clauses: vec![], }), null_treatment: None, filter: None, over: None, within_group: vec![], }), expr_from_projection(&select.projection[1]), ); match &select.projection[2] { SelectItem::ExprWithAlias { expr, alias } => { assert_eq!(&Expr::Identifier(Ident::with_quote('"', "simple id")), expr); assert_eq!(&Ident::with_quote('"', "column alias"), alias); } _ => panic!("Expected ExprWithAlias"), } clickhouse().verified_stmt(r#"CREATE TABLE "foo" ("bar" "int")"#); clickhouse().verified_stmt(r#"ALTER TABLE foo ADD CONSTRAINT "bar" PRIMARY KEY (baz)"#); //TODO verified_stmt(r#"UPDATE foo SET "bar" = 5"#); } #[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" 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_create_table_partition_by_after_order_by() { // ClickHouse DDL places PARTITION BY after ORDER BY. // MergeTree() is canonicalized to MergeTree and type names are uppercased. clickhouse().one_statement_parses_to( concat!( "CREATE TABLE IF NOT EXISTS \"MyTable\" (`col1` Int64, `col2` Int32) ", "ENGINE = MergeTree() ", "PRIMARY KEY (toDate(toDateTime(`col2`)), `col1`, `col2`) ", "ORDER BY (toDate(toDateTime(`col2`)), `col1`, `col2`) ", "PARTITION BY col1 % 64" ), concat!( "CREATE TABLE IF NOT EXISTS \"MyTable\" (`col1` INT64, `col2` Int32) ", "ENGINE = MergeTree ", "PRIMARY KEY (toDate(toDateTime(`col2`)), `col1`, `col2`) ", "ORDER BY (toDate(toDateTime(`col2`)), `col1`, `col2`) ", "PARTITION BY col1 % 64" ), ); // PARTITION BY after ORDER BY works with both ClickHouseDialect and GenericDialect clickhouse_and_generic() .verified_stmt("CREATE TABLE t (a INT) ENGINE = MergeTree ORDER BY a PARTITION BY a"); // Arithmetic expression in PARTITION BY (roundtrip) clickhouse_and_generic() .verified_stmt("CREATE TABLE t (a INT) ENGINE = MergeTree ORDER BY a PARTITION BY a % 64"); // AST: partition_by is populated with the correct expression match clickhouse_and_generic() .verified_stmt("CREATE TABLE t (a INT) ENGINE = MergeTree ORDER BY a PARTITION BY a % 64") { Statement::CreateTable(CreateTable { partition_by, .. }) => { assert_eq!( partition_by, Some(Box::new(BinaryOp { left: Box::new(Identifier(Ident::new("a"))), op: BinaryOperator::Modulo, right: Box::new(Expr::Value( Value::Number("64".parse().unwrap(), false).with_empty_span(), )), })) ); } _ => unreachable!(), } // Function call expression in PARTITION BY (ClickHouse-specific function) clickhouse().verified_stmt( "CREATE TABLE t (d DATE) ENGINE = MergeTree ORDER BY d PARTITION BY toYYYYMM(d)", ); // Negative: PARTITION BY with no expression should fail clickhouse_and_generic() .parse_sql_statements("CREATE TABLE t (a INT) ENGINE = MergeTree ORDER BY a PARTITION BY") .expect_err("PARTITION BY with no expression should fail"); } #[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] fn parse_alter_table_attach_and_detach_partition() { for operation in &["ATTACH", "DETACH"] { match clickhouse_and_generic() .verified_stmt(format!("ALTER TABLE t0 {operation} PARTITION part").as_str()) { Statement::AlterTable(alter_table) => { pretty_assertions::assert_eq!("t0", alter_table.name.to_string()); pretty_assertions::assert_eq!( alter_table.operations[0], if operation == &"ATTACH" { AlterTableOperation::AttachPartition { partition: Partition::Expr(Identifier(Ident::new("part"))), } } else { AlterTableOperation::DetachPartition { partition: Partition::Expr(Identifier(Ident::new("part"))), } } ); } _ => unreachable!(), } match clickhouse_and_generic() .verified_stmt(format!("ALTER TABLE t1 {operation} PART part").as_str()) { Statement::AlterTable(AlterTable { name, operations, .. }) => { pretty_assertions::assert_eq!("t1", name.to_string()); pretty_assertions::assert_eq!( operations[0], if operation == &"ATTACH" { AlterTableOperation::AttachPartition { partition: Partition::Part(Identifier(Ident::new("part"))), } } else { AlterTableOperation::DetachPartition { partition: Partition::Part(Identifier(Ident::new("part"))), } } ); } _ => unreachable!(), } // negative cases assert_eq!( clickhouse_and_generic() .parse_sql_statements(format!("ALTER TABLE t0 {operation} PARTITION").as_str()) .unwrap_err(), ParserError("Expected: an expression, found: EOF".to_string()) ); assert_eq!( clickhouse_and_generic() .parse_sql_statements(format!("ALTER TABLE t0 {operation} PART").as_str()) .unwrap_err(), ParserError("Expected: an expression, found: EOF".to_string()) ); } } #[test] fn parse_alter_table_add_projection() { match clickhouse_and_generic().verified_stmt(concat!( "ALTER TABLE t0 ADD PROJECTION IF NOT EXISTS my_name", " (SELECT a, b GROUP BY a ORDER BY b)", )) { Statement::AlterTable(AlterTable { name, operations, .. }) => { assert_eq!(name, ObjectName::from(vec!["t0".into()])); assert_eq!(1, operations.len()); assert_eq!( operations[0], AlterTableOperation::AddProjection { if_not_exists: true, name: "my_name".into(), select: ProjectionSelect { projection: vec![ UnnamedExpr(Identifier(Ident::new("a"))), UnnamedExpr(Identifier(Ident::new("b"))), ], group_by: Some(GroupByExpr::Expressions( vec![Identifier(Ident::new("a"))], vec![] )), order_by: Some(OrderBy { kind: OrderByKind::Expressions(vec![OrderByExpr { expr: Identifier(Ident::new("b")), options: OrderByOptions { asc: None, nulls_first: None, }, with_fill: None, }]), interpolate: None, }), } } ) } _ => unreachable!(), } // leave out IF NOT EXISTS is allowed clickhouse_and_generic() .verified_stmt("ALTER TABLE t0 ADD PROJECTION my_name (SELECT a, b GROUP BY a ORDER BY b)"); // leave out GROUP BY is allowed clickhouse_and_generic() .verified_stmt("ALTER TABLE t0 ADD PROJECTION my_name (SELECT a, b ORDER BY b)"); // leave out ORDER BY is allowed clickhouse_and_generic() .verified_stmt("ALTER TABLE t0 ADD PROJECTION my_name (SELECT a, b GROUP BY a)"); // missing select query is not allowed assert_eq!( clickhouse_and_generic() .parse_sql_statements("ALTER TABLE t0 ADD PROJECTION my_name") .unwrap_err(), ParserError("Expected: (, found: EOF".to_string()) ); assert_eq!( clickhouse_and_generic() .parse_sql_statements("ALTER TABLE t0 ADD PROJECTION my_name ()") .unwrap_err(), ParserError("Expected: SELECT, found: )".to_string()) ); assert_eq!( clickhouse_and_generic() .parse_sql_statements("ALTER TABLE t0 ADD PROJECTION my_name (SELECT)") .unwrap_err(), ParserError("Expected: an expression, found: )".to_string()) ); } #[test] fn parse_alter_table_drop_projection() { match clickhouse_and_generic().verified_stmt("ALTER TABLE t0 DROP PROJECTION IF EXISTS my_name") { Statement::AlterTable(AlterTable { name, operations, .. }) => { assert_eq!(name, ObjectName::from(vec!["t0".into()])); assert_eq!(1, operations.len()); assert_eq!( operations[0], AlterTableOperation::DropProjection { if_exists: true, name: "my_name".into(), } ) } _ => unreachable!(), } // allow to skip `IF EXISTS` clickhouse_and_generic().verified_stmt("ALTER TABLE t0 DROP PROJECTION my_name"); assert_eq!( clickhouse_and_generic() .parse_sql_statements("ALTER TABLE t0 DROP PROJECTION") .unwrap_err(), ParserError("Expected: identifier, found: EOF".to_string()) ); } #[test] fn parse_alter_table_clear_and_materialize_projection() { for keyword in ["CLEAR", "MATERIALIZE"] { match clickhouse_and_generic().verified_stmt( format!("ALTER TABLE t0 {keyword} PROJECTION IF EXISTS my_name IN PARTITION p0",) .as_str(), ) { Statement::AlterTable(AlterTable { name, operations, .. }) => { assert_eq!(name, ObjectName::from(vec!["t0".into()])); assert_eq!(1, operations.len()); assert_eq!( operations[0], if keyword == "CLEAR" { AlterTableOperation::ClearProjection { if_exists: true, name: "my_name".into(), partition: Some(Ident::new("p0")), } } else { AlterTableOperation::MaterializeProjection { if_exists: true, name: "my_name".into(), partition: Some(Ident::new("p0")), } } ) } _ => unreachable!(), } // allow to skip `IF EXISTS` clickhouse_and_generic().verified_stmt( format!("ALTER TABLE t0 {keyword} PROJECTION my_name IN PARTITION p0",).as_str(), ); // allow to skip `IN PARTITION partition_name` clickhouse_and_generic() .verified_stmt(format!("ALTER TABLE t0 {keyword} PROJECTION my_name",).as_str()); assert_eq!( clickhouse_and_generic() .parse_sql_statements(format!("ALTER TABLE t0 {keyword} PROJECTION",).as_str()) .unwrap_err(), ParserError("Expected: identifier, found: EOF".to_string()) ); assert_eq!( clickhouse_and_generic() .parse_sql_statements( format!("ALTER TABLE t0 {keyword} PROJECTION my_name IN PARTITION",).as_str() ) .unwrap_err(), ParserError("Expected: identifier, found: EOF".to_string()) ); assert_eq!( clickhouse_and_generic() .parse_sql_statements( format!("ALTER TABLE t0 {keyword} PROJECTION my_name IN",).as_str() ) .unwrap_err(), ParserError("Expected: end of statement, found: IN".to_string()) ); } } #[test] fn parse_optimize_table() { clickhouse_and_generic().verified_stmt("OPTIMIZE TABLE t0"); clickhouse_and_generic().verified_stmt("OPTIMIZE TABLE db.t0"); clickhouse_and_generic().verified_stmt("OPTIMIZE TABLE t0 ON CLUSTER 'cluster'"); clickhouse_and_generic().verified_stmt("OPTIMIZE TABLE t0 ON CLUSTER 'cluster' FINAL"); clickhouse_and_generic().verified_stmt("OPTIMIZE TABLE t0 FINAL DEDUPLICATE"); clickhouse_and_generic().verified_stmt("OPTIMIZE TABLE t0 DEDUPLICATE"); clickhouse_and_generic().verified_stmt("OPTIMIZE TABLE t0 DEDUPLICATE BY id"); clickhouse_and_generic().verified_stmt("OPTIMIZE TABLE t0 FINAL DEDUPLICATE BY id"); clickhouse_and_generic() .verified_stmt("OPTIMIZE TABLE t0 PARTITION tuple('2023-04-22') DEDUPLICATE BY id"); match clickhouse_and_generic().verified_stmt( "OPTIMIZE TABLE t0 ON CLUSTER cluster PARTITION ID '2024-07' FINAL DEDUPLICATE BY id", ) { Statement::OptimizeTable { name, on_cluster, partition, include_final, deduplicate, .. } => { assert_eq!(name.to_string(), "t0"); assert_eq!(on_cluster, Some(Ident::new("cluster"))); assert_eq!( partition, Some(Partition::Identifier(Ident::with_quote('\'', "2024-07"))) ); assert!(include_final); assert_eq!( deduplicate, Some(Deduplicate::ByExpression(Identifier(Ident::new("id")))) ); } _ => unreachable!(), } // negative cases assert_eq!( clickhouse_and_generic() .parse_sql_statements("OPTIMIZE TABLE t0 DEDUPLICATE BY") .unwrap_err(), ParserError("Expected: an expression, found: EOF".to_string()) ); assert_eq!( clickhouse_and_generic() .parse_sql_statements("OPTIMIZE TABLE t0 PARTITION") .unwrap_err(), ParserError("Expected: an expression, found: EOF".to_string()) ); assert_eq!( clickhouse_and_generic() .parse_sql_statements("OPTIMIZE TABLE t0 PARTITION ID") .unwrap_err(), ParserError("Expected: identifier, found: EOF".to_string()) ); } fn column_def(name: Ident, data_type: DataType) -> ColumnDef { ColumnDef { name, data_type, options: vec![], } } #[test] fn parse_clickhouse_data_types() { let sql = concat!( "CREATE TABLE table (", "a1 UInt8, a2 UInt16, a3 UInt32, a4 UInt64, a5 UInt128, a6 UInt256,", " b1 Int8, b2 Int16, b3 Int32, b4 Int64, b5 Int128, b6 Int256,", " c1 Float32, c2 Float64,", " d1 Date32, d2 DateTime64(3), d3 DateTime64(3, 'UTC'),", " e1 FixedString(255),", " f1 LowCardinality(Int32)", ") ORDER BY (a1)", ); // ClickHouse has a case-sensitive definition of data type, but canonical representation is not let canonical_sql = sql .replace(" Int8", " INT8") .replace(" Int64", " INT64") .replace(" Float64", " FLOAT64"); 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!( columns, vec![ column_def("a1".into(), DataType::UInt8), column_def("a2".into(), DataType::UInt16), column_def("a3".into(), DataType::UInt32), column_def("a4".into(), DataType::UInt64), column_def("a5".into(), DataType::UInt128), column_def("a6".into(), DataType::UInt256), column_def("b1".into(), DataType::Int8(None)), column_def("b2".into(), DataType::Int16), column_def("b3".into(), DataType::Int32), column_def("b4".into(), DataType::Int64), column_def("b5".into(), DataType::Int128), column_def("b6".into(), DataType::Int256), column_def("c1".into(), DataType::Float32), column_def("c2".into(), DataType::Float64), column_def("d1".into(), DataType::Date32), column_def("d2".into(), DataType::Datetime64(3, None)), column_def("d3".into(), DataType::Datetime64(3, Some("UTC".into()))), column_def("e1".into(), DataType::FixedString(255)), column_def( "f1".into(), DataType::LowCardinality(Box::new(DataType::Int32)) ), ] ); } _ => unreachable!(), } } #[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`)"#; // 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!( columns, vec![ column_def("k".into(), DataType::UInt8), column_def( Ident::with_quote('`', "a"), DataType::Nullable(Box::new(DataType::String(None))) ), column_def( Ident::with_quote('`', "b"), DataType::Nullable(Box::new(DataType::Datetime64( 9, Some("UTC".to_string()) ))) ), column_def( "c".into(), DataType::Nullable(Box::new(DataType::Datetime64(9, None))) ), ColumnDef { name: "d".into(), data_type: DataType::Date32, options: vec![ColumnOptionDef { name: None, option: ColumnOption::Null }], } ] ); } _ => unreachable!(), } } #[test] fn parse_create_table_with_nested_data_types() { let sql = concat!( "CREATE TABLE table (", " i Nested(a Array(Int16), b LowCardinality(String)),", " k Array(Tuple(FixedString(128), Int128)),", " l Tuple(a DateTime64(9), b Array(UUID)),", " m Map(String, UInt16)", ") ENGINE=MergeTree ORDER BY (k)" ); match clickhouse().one_statement_parses_to(sql, "") { Statement::CreateTable(CreateTable { name, columns, .. }) => { assert_eq!(name, ObjectName::from(vec!["table".into()])); assert_eq!( columns, vec![ ColumnDef { name: Ident::new("i"), data_type: DataType::Nested(vec![ column_def( "a".into(), DataType::Array(ArrayElemTypeDef::Parenthesis(Box::new( DataType::Int16 ),)) ), column_def( "b".into(), DataType::LowCardinality(Box::new(DataType::String(None))) ) ]), options: vec![], }, ColumnDef { name: Ident::new("k"), data_type: DataType::Array(ArrayElemTypeDef::Parenthesis(Box::new( DataType::Tuple(vec![ StructField { field_name: None, field_type: DataType::FixedString(128), options: None, }, StructField { field_name: None, field_type: DataType::Int128, options: None, } ]) ))), options: vec![], }, ColumnDef { name: Ident::new("l"), data_type: DataType::Tuple(vec![ 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, }, ]), options: vec![], }, ColumnDef { name: Ident::new("m"), data_type: DataType::Map( Box::new(DataType::String(None)), Box::new(DataType::UInt16) ), options: vec![], }, ] ); } _ => unreachable!(), } } #[test] 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}')", " PRIMARY KEY tuple(i)", " ORDER BY tuple(i)", )) { Statement::CreateTable(CreateTable { name, columns, table_options, primary_key, order_by, .. }) => { assert_eq!(name.to_string(), "db.table"); assert_eq!( vec![ ColumnDef { name: Ident::with_quote('`', "i"), data_type: DataType::Int(None), options: vec![], }, ColumnDef { name: Ident::with_quote('`', "k"), data_type: DataType::Int(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![ 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.args, FunctionArguments::List(FunctionArgumentList { args: vec![FunctionArg::Unnamed(FunctionArgExpr::Expr(Identifier( Ident::new(arg) )),)], duplicate_treatment: None, clauses: vec![], }) ); true } match primary_key.unwrap().as_ref() { Expr::Function(primary_key) => { assert!(assert_function(primary_key, "tuple", "i")); } _ => panic!("unexpected primary key type"), } match order_by { Some(OneOrManyWithParens::One(Expr::Function(order_by))) => { assert!(assert_function(&order_by, "tuple", "i")); } _ => panic!("unexpected order by type"), }; } _ => unreachable!(), } clickhouse_and_generic() .parse_sql_statements(concat!( r#"CREATE TABLE db.table (`i` Int, `k` Int)"#, " ORDER BY tuple(i), tuple(k)", )) .expect_err("ORDER BY supports one expression with tuple"); } #[test] fn parse_create_table_with_variant_default_expressions() { let sql = concat!( "CREATE TABLE table (", "a DATETIME MATERIALIZED now(),", " b DATETIME EPHEMERAL now(),", " c DATETIME EPHEMERAL,", " d STRING ALIAS toString(c)", ") ENGINE = MergeTree" ); match clickhouse_and_generic().verified_stmt(sql) { Statement::CreateTable(CreateTable { columns, .. }) => { assert_eq!( columns, vec![ ColumnDef { name: Ident::new("a"), data_type: DataType::Datetime(None), options: vec![ColumnOptionDef { name: None, option: ColumnOption::Materialized(Expr::Function(Function { name: ObjectName::from(vec![Ident::new("now")]), uses_odbc_syntax: false, args: FunctionArguments::List(FunctionArgumentList { args: vec![], duplicate_treatment: None, clauses: vec![], }), parameters: FunctionArguments::None, null_treatment: None, filter: None, over: None, within_group: vec![], })) }], }, ColumnDef { name: Ident::new("b"), data_type: DataType::Datetime(None), options: vec![ColumnOptionDef { name: None, option: ColumnOption::Ephemeral(Some(Expr::Function(Function { name: ObjectName::from(vec![Ident::new("now")]), uses_odbc_syntax: false, args: FunctionArguments::List(FunctionArgumentList { args: vec![], duplicate_treatment: None, clauses: vec![], }), parameters: FunctionArguments::None, null_treatment: None, filter: None, over: None, within_group: vec![], }))) }], }, ColumnDef { name: Ident::new("c"), data_type: DataType::Datetime(None), options: vec![ColumnOptionDef { name: None, option: ColumnOption::Ephemeral(None) }], }, ColumnDef { name: Ident::new("d"), data_type: DataType::String(None), options: vec![ColumnOptionDef { name: None, option: ColumnOption::Alias(Expr::Function(Function { name: ObjectName::from(vec![Ident::new("toString")]), uses_odbc_syntax: false, args: FunctionArguments::List(FunctionArgumentList { args: vec![FunctionArg::Unnamed(FunctionArgExpr::Expr( Identifier(Ident::new("c")) ))], duplicate_treatment: None, clauses: vec![], }), parameters: FunctionArguments::None, null_treatment: None, filter: None, over: None, within_group: vec![], })) }], } ] ) } _ => unreachable!(), } } #[test] 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(CreateView { name, columns, .. }) => { assert_eq!(name, ObjectName::from(vec!["v".into()])); assert_eq!( columns, vec![ ViewColumnDef { name: "i".into(), data_type: Some(DataType::Custom( ObjectName::from(vec![Ident { value: "int".into(), quote_style: Some('"'), span: Span::empty(), }]), vec![] )), options: None, }, ViewColumnDef { name: "f".into(), data_type: Some(DataType::Custom( ObjectName::from(vec![Ident { value: "String".into(), quote_style: Some('"'), span: Span::empty(), }]), vec![] )), options: None, }, ] ); } _ => unreachable!(), } clickhouse() .parse_sql_statements(r#"CREATE VIEW v (i, f) AS SELECT * FROM t"#) .expect_err("CREATE VIEW with fields and without data types should be invalid"); } #[test] fn parse_double_equal() { clickhouse().one_statement_parses_to( r#"SELECT foo FROM bar WHERE buz == 'buz'"#, r#"SELECT foo FROM bar WHERE buz = 'buz'"#, ); } #[test] 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"#, ); 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) { match clickhouse_and_generic().verified_stmt(sql) { Statement::Query(q) => { assert_eq!(q.settings, Some(expected)); } _ => unreachable!(), } } for (sql, expected_settings) in [ ( r#"SELECT * FROM t SETTINGS max_threads = 1, max_block_size = 10000"#, vec![ Setting { key: Ident::new("max_threads"), value: Expr::value(number("1")), }, Setting { key: Ident::new("max_block_size"), value: Expr::value(number("10000")), }, ], ), ( r#"SELECT * FROM t SETTINGS additional_table_filters = {'table_1': 'x != 2'}"#, vec![Setting { key: Ident::new("additional_table_filters"), value: Expr::Dictionary(vec![DictionaryField { key: Ident::with_quote('\'', "table_1"), value: Expr::value(single_quoted_string("x != 2")).into(), }]), }], ), ( r#"SELECT * FROM t SETTINGS additional_result_filter = 'x != 2', query_plan_optimize_lazy_materialization = false"#, vec![ Setting { key: Ident::new("additional_result_filter"), value: Expr::value(single_quoted_string("x != 2")), }, Setting { key: Ident::new("query_plan_optimize_lazy_materialization"), value: Expr::value(Boolean(false)), }, ], ), ] { check_settings(sql, expected_settings); } let invalid_cases = vec![ ("SELECT * FROM t SETTINGS a", "Expected: =, found: EOF"), ( "SELECT * FROM t SETTINGS a=", "Expected: an expression, found: EOF", ), ("SELECT * FROM t SETTINGS a=1, b", "Expected: =, found: EOF"), ( "SELECT * FROM t SETTINGS a=1, b=", "Expected: an expression, found: EOF", ), ( "SELECT * FROM t SETTINGS a = {", "Expected: identifier, found: EOF", ), ( "SELECT * FROM t SETTINGS a = {'b'", "Expected: :, found: EOF", ), ( "SELECT * FROM t SETTINGS a = {'b': ", "Expected: an expression, found: EOF", ), ( "SELECT * FROM t SETTINGS a = {'b': 'c',}", "Expected: identifier, found: }", ), ( "SELECT * FROM t SETTINGS a = {'b': 'c', 'd'}", "Expected: :, found: }", ), ( "SELECT * FROM t SETTINGS a = {'b': 'c', 'd': }", "Expected: an expression, found: }", ), ( "SELECT * FROM t SETTINGS a = {ANY(b)}", "Expected: :, found: (", ), ]; for (sql, error_msg) in invalid_cases { assert_eq!( clickhouse_and_generic() .parse_sql_statements(sql) .unwrap_err(), ParserError(error_msg.to_string()) ); } } #[test] fn parse_select_star_except() { clickhouse().verified_stmt("SELECT * EXCEPT (prev_status) FROM anomalies"); } #[test] fn parse_select_parametric_function() { match clickhouse_and_generic().verified_stmt("SELECT HISTOGRAM(0.5, 0.6)(x, y) FROM t") { Statement::Query(query) => { let projection: &Vec = query.body.as_select().unwrap().projection.as_ref(); assert_eq!(projection.len(), 1); match &projection[0] { UnnamedExpr(Expr::Function(f)) => { let args = match &f.args { FunctionArguments::List(ref args) => args, _ => unreachable!(), }; assert_eq!(args.args.len(), 2); assert_eq!( args.args[0], FunctionArg::Unnamed(FunctionArgExpr::Expr(Identifier(Ident::from("x")))) ); assert_eq!( args.args[1], FunctionArg::Unnamed(FunctionArgExpr::Expr(Identifier(Ident::from("y")))) ); let parameters = match f.parameters { FunctionArguments::List(ref args) => args, _ => unreachable!(), }; 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() ))) ); assert_eq!( parameters.args[1], FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::Value( (Value::Number("0.6".parse().unwrap(), false)).with_empty_span() ))) ); } _ => unreachable!(), } } _ => unreachable!(), } } #[test] fn parse_select_star_except_no_parens() { clickhouse().one_statement_parses_to( "SELECT * EXCEPT prev_status FROM anomalies", "SELECT * EXCEPT (prev_status) FROM anomalies", ); } #[test] fn parse_create_materialized_view() { // example sql // https://clickhouse.com/docs/en/guides/developer/cascading-materialized-views let sql = concat!( "CREATE MATERIALIZED VIEW analytics.monthly_aggregated_data_mv ", "TO analytics.monthly_aggregated_data ", "AS SELECT toDate(toStartOfMonth(event_time)) ", "AS month, domain_name, sumState(count_views) ", "AS sumCountViews FROM analytics.hourly_data ", "GROUP BY domain_name, month" ); clickhouse_and_generic().verified_stmt(sql); } #[test] fn parse_select_order_by_with_fill_interpolate() { let sql = "SELECT id, fname, lname FROM customer WHERE id < 5 \ ORDER BY \ fname ASC NULLS FIRST WITH FILL FROM 10 TO 20 STEP 2, \ lname DESC NULLS LAST WITH FILL FROM 30 TO 40 STEP 3 \ INTERPOLATE (col1 AS col1 + 1) \ LIMIT 2"; let select = clickhouse().verified_query(sql); assert_eq!( OrderBy { kind: OrderByKind::Expressions(vec![ OrderByExpr { expr: Expr::Identifier(Ident::new("fname")), options: OrderByOptions { asc: Some(true), nulls_first: Some(true), }, with_fill: Some(WithFill { from: Some(Expr::value(number("10"))), to: Some(Expr::value(number("20"))), step: Some(Expr::value(number("2"))), }), }, OrderByExpr { expr: Expr::Identifier(Ident::new("lname")), options: OrderByOptions { asc: Some(false), nulls_first: Some(false), }, with_fill: Some(WithFill { from: Some(Expr::value(number("30"))), to: Some(Expr::value(number("40"))), step: Some(Expr::value(number("3"))), }), }, ]), 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"))), }), }]) }) }, 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![] }) ); } #[test] fn parse_select_order_by_with_fill_interpolate_multi_interpolates() { let sql = "SELECT id, fname, lname FROM customer ORDER BY fname WITH FILL \ INTERPOLATE (col1 AS col1 + 1) INTERPOLATE (col2 AS col2 + 2)"; clickhouse_and_generic() .parse_sql_statements(sql) .expect_err("ORDER BY only accepts a single INTERPOLATE clause"); } #[test] fn parse_select_order_by_with_fill_interpolate_multi_with_fill_interpolates() { let sql = "SELECT id, fname, lname FROM customer \ ORDER BY \ fname WITH FILL INTERPOLATE (col1 AS col1 + 1), \ lname WITH FILL INTERPOLATE (col2 AS col2 + 2)"; clickhouse_and_generic() .parse_sql_statements(sql) .expect_err("ORDER BY only accepts a single INTERPOLATE clause"); } #[test] fn parse_select_order_by_interpolate_not_last() { let sql = "SELECT id, fname, lname FROM customer \ ORDER BY \ fname INTERPOLATE (col2 AS col2 + 2), lname"; clickhouse_and_generic() .parse_sql_statements(sql) .expect_err("ORDER BY INTERPOLATE must be in the last position"); } #[test] fn parse_with_fill() { let sql = "SELECT fname FROM customer ORDER BY fname \ WITH FILL FROM 10 TO 20 STEP 2"; 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, } ); } #[test] fn parse_with_fill_missing_single_argument() { let sql = "SELECT id, fname, lname FROM customer ORDER BY \ fname WITH FILL FROM TO 20"; clickhouse_and_generic() .parse_sql_statements(sql) .expect_err("WITH FILL requires expressions for all arguments"); } #[test] fn parse_with_fill_multiple_incomplete_arguments() { let sql = "SELECT id, fname, lname FROM customer ORDER BY \ fname WITH FILL FROM TO 20, lname WITH FILL FROM TO STEP 1"; clickhouse_and_generic() .parse_sql_statements(sql) .expect_err("WITH FILL requires expressions for all arguments"); } #[test] fn parse_interpolate_body_with_columns() { let sql = "SELECT fname FROM customer ORDER BY fname WITH FILL \ INTERPOLATE (col1 AS col1 + 1, col2 AS col3, col4 AS col4 + 4)"; let select = clickhouse().verified_query(sql); assert_eq!( 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"))), }), }, InterpolateExpr { column: Ident::new("col2"), expr: Some(Expr::Identifier(Ident::new("col3"))), }, InterpolateExpr { column: Ident::new("col4"), expr: Some(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("col4"))), op: BinaryOperator::Plus, right: Box::new(Expr::value(number("4"))), }), }, ]) }) .as_ref(), select .order_by .expect("ORDER BY expected") .interpolate .as_ref() ); } #[test] 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() ); } #[test] fn parse_interpolate_with_empty_body() { let sql = "SELECT fname FROM customer ORDER BY fname WITH FILL INTERPOLATE ()"; let select = clickhouse().verified_query(sql); assert_eq!( Some(Interpolate { exprs: Some(vec![]) }) .as_ref(), select .order_by .expect("ORDER BY expected") .interpolate .as_ref() ); } #[test] fn test_prewhere() { match clickhouse_and_generic().verified_stmt("SELECT * FROM t PREWHERE x = 1 WHERE y = 2") { Statement::Query(query) => { let prewhere = query.body.as_select().unwrap().prewhere.as_ref(); assert_eq!( 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() )), }) ); let selection = query.as_ref().body.as_select().unwrap().selection.as_ref(); assert_eq!( selection, 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() )), }) ); } _ => unreachable!(), } match clickhouse_and_generic().verified_stmt("SELECT * FROM t PREWHERE x = 1 AND y = 2") { Statement::Query(query) => { let prewhere = query.body.as_select().unwrap().prewhere.as_ref(); assert_eq!( prewhere, Some(&BinaryOp { 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() )), }), 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() )), }), }) ); } _ => unreachable!(), } } #[test] fn parse_use() { let valid_object_names = [ "mydb", "SCHEMA", "DATABASE", "CATALOG", "WAREHOUSE", "DEFAULT", ]; let quote_styles = ['"', '`']; 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( 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( quote, object_name.to_string(), )]))) ); } } } #[test] 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}"); match clickhouse_and_generic().verified_stmt(&sql) { Statement::Query(query) => { if *format == "NULL" { assert_eq!(query.format_clause, Some(FormatClause::Null)); } else { assert_eq!( query.format_clause, Some(FormatClause::Identifier(Ident::new(*format))) ); } } _ => unreachable!(), } } let invalid_cases = [ "SELECT * FROM t FORMAT", "SELECT * FROM t FORMAT TabSeparated JSONCompact", "SELECT * FROM t FORMAT TabSeparated TabSeparated", ]; for sql in &invalid_cases { clickhouse_and_generic() .parse_sql_statements(sql) .expect_err("Expected: FORMAT {identifier}, found: "); } } #[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"#; match clickhouse_and_generic().verified_stmt(sql) { Statement::CreateTable(CreateTable { name, on_commit, query, .. }) => { assert_eq!(name.to_string(), "test"); 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() ))] ); } _ => unreachable!(), } } #[test] fn parse_freeze_and_unfreeze_partition() { // test cases without `WITH NAME` 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(), )); match clickhouse_and_generic().verified_stmt(&sql) { Statement::AlterTable(AlterTable { operations, .. }) => { assert_eq!(operations.len(), 1); let expected_operation = if operation_name == &"FREEZE" { AlterTableOperation::FreezePartition { partition: expected_partition, with_name: None, } } else { AlterTableOperation::UnfreezePartition { partition: expected_partition, with_name: None, } }; assert_eq!(operations[0], expected_operation); } _ => unreachable!(), } } // test case with `WITH NAME` for operation_name in &["FREEZE", "UNFREEZE"] { let sql = format!("ALTER TABLE t {operation_name} PARTITION '2024-08-14' WITH NAME 'hello'"); match clickhouse_and_generic().verified_stmt(&sql) { Statement::AlterTable(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_operation = if operation_name == &"FREEZE" { AlterTableOperation::FreezePartition { partition: expected_partition, with_name: Some(Ident::with_quote('\'', "hello")), } } else { AlterTableOperation::UnfreezePartition { partition: expected_partition, with_name: Some(Ident::with_quote('\'', "hello")), } }; assert_eq!(operations[0], expected_operation); } _ => unreachable!(), } } // negative cases for operation_name in &["FREEZE", "UNFREEZE"] { assert_eq!( clickhouse_and_generic() .parse_sql_statements(format!("ALTER TABLE t0 {operation_name} PARTITION").as_str()) .unwrap_err(), ParserError("Expected: an expression, found: EOF".to_string()) ); assert_eq!( clickhouse_and_generic() .parse_sql_statements( format!("ALTER TABLE t0 {operation_name} PARTITION p0 WITH").as_str() ) .unwrap_err(), ParserError("Expected: NAME, found: EOF".to_string()) ); assert_eq!( clickhouse_and_generic() .parse_sql_statements( format!("ALTER TABLE t0 {operation_name} PARTITION p0 WITH NAME").as_str() ) .unwrap_err(), ParserError("Expected: identifier, found: EOF".to_string()) ); } } #[test] fn parse_select_table_function_settings() { fn check_settings(sql: &str, expected: &TableFunctionArgs) { match clickhouse_and_generic().verified_stmt(sql) { Statement::Query(q) => { let from = &q.body.as_select().unwrap().from; assert_eq!(from.len(), 1); assert_eq!(from[0].joins, vec![]); match &from[0].relation { Table { args, .. } => { let args = args.as_ref().unwrap(); assert_eq!(args, expected); } _ => unreachable!(), } } _ => unreachable!(), } } check_settings( "SELECT * FROM table_function(arg, SETTINGS s0 = 3, s1 = 's')", &TableFunctionArgs { args: vec![FunctionArg::Unnamed(FunctionArgExpr::Expr( Expr::Identifier("arg".into()), ))], settings: Some(vec![ Setting { key: "s0".into(), value: Expr::value(number("3")), }, Setting { key: "s1".into(), value: Expr::value(single_quoted_string("s")), }, ]), }, ); check_settings( r#"SELECT * FROM table_function(arg)"#, &TableFunctionArgs { args: vec![FunctionArg::Unnamed(FunctionArgExpr::Expr( Expr::Identifier("arg".into()), ))], settings: None, }, ); check_settings( "SELECT * FROM table_function(SETTINGS s0 = 3, s1 = 's')", &TableFunctionArgs { args: vec![], settings: Some(vec![ Setting { key: "s0".into(), value: Expr::value(number("3")), }, Setting { key: "s1".into(), value: Expr::value(single_quoted_string("s")), }, ]), }, ); let invalid_cases = vec![ "SELECT * FROM t(SETTINGS a)", "SELECT * FROM t(SETTINGS a=)", "SELECT * FROM t(SETTINGS a=1, b)", "SELECT * FROM t(SETTINGS a=1, b=)", ]; for sql in invalid_cases { clickhouse_and_generic() .parse_sql_statements(sql) .expect_err("Expected: SETTINGS key = value, found: "); } } #[test] fn explain_describe() { clickhouse().verified_stmt("DESCRIBE test.table"); clickhouse().verified_stmt("DESCRIBE TABLE test.table"); } #[test] fn explain_desc() { clickhouse().verified_stmt("DESC test.table"); clickhouse().verified_stmt("DESC TABLE test.table"); } #[test] fn parse_explain_table() { match clickhouse().verified_stmt("EXPLAIN TABLE test_identifier") { Statement::ExplainTable { describe_alias, hive_format, has_table_keyword, table_name, } => { pretty_assertions::assert_eq!(describe_alias, DescribeAlias::Explain); pretty_assertions::assert_eq!(hive_format, None); pretty_assertions::assert_eq!(has_table_keyword, true); pretty_assertions::assert_eq!("test_identifier", table_name.to_string()); } _ => panic!("Unexpected Statement, must be ExplainTable"), } } #[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"); } #[test] fn test_parse_not_null_in_column_options() { // In addition to DEFAULT and CHECK ClickHouse also supports MATERIALIZED, all of which // can contain `IS NOT NULL` and thus `NOT NULL` as an alias. let canonical = concat!( "CREATE TABLE foo (", "abc INT DEFAULT (42 IS NOT NULL) NOT NULL,", " not_null BOOL MATERIALIZED (abc IS NOT NULL),", " CHECK (abc IS NOT NULL)", ")", ); clickhouse().verified_stmt(canonical); clickhouse().one_statement_parses_to( concat!( "CREATE TABLE foo (", "abc INT DEFAULT (42 NOT NULL) NOT NULL,", " not_null BOOL MATERIALIZED (abc NOT NULL),", " CHECK (abc NOT NULL)", ")", ), canonical, ); } #[test] fn parse_array_join() { // ARRAY JOIN works with both ClickHouseDialect and GenericDialect (roundtrip) clickhouse_and_generic().verified_stmt("SELECT x FROM t ARRAY JOIN arr AS x"); // AST: join_operator is the unit variant ArrayJoin (no constraint) match clickhouse_and_generic().verified_stmt("SELECT x FROM t ARRAY JOIN arr AS x") { Statement::Query(query) => { let select = query.body.as_select().unwrap(); let join = &select.from[0].joins[0]; assert_eq!(join.join_operator, JoinOperator::ArrayJoin); } _ => unreachable!(), } // Combined: regular JOIN followed by ARRAY JOIN clickhouse_and_generic() .verified_stmt("SELECT x FROM t JOIN u ON t.id = u.id ARRAY JOIN arr AS x"); // Negative: ARRAY JOIN with no table expression should fail clickhouse_and_generic() .parse_sql_statements("SELECT x FROM t ARRAY JOIN") .expect_err("ARRAY JOIN requires a table expression"); } #[test] fn parse_left_array_join() { // LEFT ARRAY JOIN preserves rows with empty/null arrays (roundtrip) clickhouse_and_generic().verified_stmt("SELECT x FROM t LEFT ARRAY JOIN arr AS x"); // AST: join_operator is LeftArrayJoin match clickhouse_and_generic().verified_stmt("SELECT x FROM t LEFT ARRAY JOIN arr AS x") { Statement::Query(query) => { let select = query.body.as_select().unwrap(); let join = &select.from[0].joins[0]; assert_eq!(join.join_operator, JoinOperator::LeftArrayJoin); } _ => unreachable!(), } } #[test] fn parse_inner_array_join() { // INNER ARRAY JOIN filters rows with empty/null arrays (roundtrip) clickhouse_and_generic().verified_stmt("SELECT x FROM t INNER ARRAY JOIN arr AS x"); // AST: join_operator is InnerArrayJoin match clickhouse_and_generic().verified_stmt("SELECT x FROM t INNER ARRAY JOIN arr AS x") { Statement::Query(query) => { let select = query.body.as_select().unwrap(); let join = &select.from[0].joins[0]; assert_eq!(join.join_operator, JoinOperator::InnerArrayJoin); } _ => unreachable!(), } } fn clickhouse() -> TestedDialects { TestedDialects::new(vec![Box::new(ClickHouseDialect {})]) } fn clickhouse_and_generic() -> TestedDialects { TestedDialects::new(vec![ Box::new(ClickHouseDialect {}), Box::new(GenericDialect {}), ]) } apache-datafusion-sqlparser-rs-0.62.0/tests/sqlparser_comments.rs000066400000000000000000000046241517524037000252520ustar00rootroot00000000000000// 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. #![warn(clippy::all)] //! Test comment extraction from SQL source code. #[cfg(test)] use pretty_assertions::assert_eq; use sqlparser::{ ast::comments::{Comment, CommentWithSpan}, dialect::GenericDialect, parser::Parser, tokenizer::Span, }; #[test] fn parse_sql_with_comments() { let sql = r#" -- second line comment select * from /* inline comment after `from` */ dual; /*select some more*/ -- end-of-script-with-no-newline"#; let comments = match Parser::parse_sql_with_comments(&GenericDialect, sql) { Ok((_, comments)) => comments, Err(e) => panic!("Invalid sql script: {e}"), }; assert_eq!( Vec::from(comments), vec![ CommentWithSpan { comment: Comment::SingleLine { content: " second line comment\n".into(), prefix: "--".into() }, span: Span::new((2, 1).into(), (3, 1).into()), }, CommentWithSpan { comment: Comment::MultiLine(" inline comment after `from` ".into()), span: Span::new((3, 15).into(), (3, 48).into()), }, CommentWithSpan { comment: Comment::MultiLine("select\nsome\nmore".into()), span: Span::new((5, 1).into(), (7, 7).into()) }, CommentWithSpan { comment: Comment::SingleLine { content: " end-of-script-with-no-newline".into(), prefix: "--".into() }, span: Span::new((9, 3).into(), (9, 35).into()), } ] ); } apache-datafusion-sqlparser-rs-0.62.0/tests/sqlparser_common.rs000066400000000000000000024037561517524037000247300ustar00rootroot00000000000000// 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. #![warn(clippy::all)] //! Test SQL syntax, which all sqlparser dialects must parse in the same way. //! //! Note that it does not mean all SQL here is valid in all the dialects, only //! that 1) it's either standard or widely supported and 2) it can be parsed by //! sqlparser regardless of the chosen dialect (i.e. it doesn't conflict with //! dialect-specific parsing rules). extern crate core; use helpers::attached_token::AttachedToken; use matches::assert_matches; use sqlparser::ast::helpers::key_value_options::*; use sqlparser::ast::helpers::key_value_options::{KeyValueOptions, KeyValueOptionsDelimiter}; use sqlparser::ast::SelectItem::UnnamedExpr; use sqlparser::ast::TableFactor::{Pivot, Unpivot}; use sqlparser::ast::*; use sqlparser::dialect::{ AnsiDialect, BigQueryDialect, ClickHouseDialect, DatabricksDialect, Dialect, DuckDbDialect, GenericDialect, HiveDialect, MsSqlDialect, MySqlDialect, OracleDialect, PostgreSqlDialect, RedshiftSqlDialect, SQLiteDialect, SnowflakeDialect, }; use sqlparser::keywords::{Keyword, ALL_KEYWORDS}; use sqlparser::parser::{Parser, ParserError, ParserOptions}; use sqlparser::tokenizer::Tokenizer; use sqlparser::tokenizer::{Location, Span}; use test_utils::{ all_dialects, all_dialects_where, all_dialects_with_options, alter_table_op, assert_eq_vec, call, expr_from_projection, join, number, only, table, table_alias, table_from_name, TestedDialects, }; #[macro_use] mod test_utils; #[cfg(test)] use pretty_assertions::assert_eq; use sqlparser::ast::ColumnOption::Comment; use sqlparser::ast::DateTimeField::Seconds; use sqlparser::ast::Expr::{Identifier, UnaryOp}; use sqlparser::ast::Value::Number; use sqlparser::test_utils::all_dialects_except; #[test] fn parse_numeric_literal_underscore() { let dialects = all_dialects_where(|d| d.supports_numeric_literal_underscores()); let canonical = if cfg!(feature = "bigdecimal") { "SELECT 10000" } else { "SELECT 10_000" }; let select = dialects.verified_only_select_with_canonical("SELECT 10_000", canonical); assert_eq!( select.projection, vec![UnnamedExpr(Expr::Value(number("10_000").with_empty_span()))] ); } #[test] fn parse_function_object_name() { let select = verified_only_select("SELECT a.b.c.d(1, 2, 3) FROM T"); let Expr::Function(func) = expr_from_projection(&select.projection[0]) else { unreachable!() }; assert_eq!( ObjectName::from( ["a", "b", "c", "d"] .into_iter() .map(Ident::new) .collect::>() ), func.name, ); } #[test] fn parse_insert_values() { let row = vec![ Expr::value(number("1")), Expr::value(number("2")), Expr::value(number("3")), ]; let rows1 = vec![Parens::with_empty_span(row.clone())]; let rows2 = vec![ Parens::with_empty_span(row.clone()), Parens::with_empty_span(row), ]; let sql = "INSERT customer VALUES (1, 2, 3)"; check_one(sql, "customer", &[], &rows1, false); let sql = "INSERT INTO customer VALUES (1, 2, 3)"; check_one(sql, "customer", &[], &rows1, false); let sql = "INSERT INTO customer VALUES (1, 2, 3), (1, 2, 3)"; check_one(sql, "customer", &[], &rows2, false); let sql = "INSERT INTO public.customer VALUES (1, 2, 3)"; check_one(sql, "public.customer", &[], &rows1, false); let sql = "INSERT INTO db.public.customer VALUES (1, 2, 3)"; check_one(sql, "db.public.customer", &[], &rows1, false); let sql = "INSERT INTO public.customer (id, name, active) VALUES (1, 2, 3)"; check_one( sql, "public.customer", &["id".to_string(), "name".to_string(), "active".to_string()], &rows1, false, ); let sql = r"INSERT INTO t (id, name, active) VALUE (1, 2, 3)"; check_one( sql, "t", &["id".to_string(), "name".to_string(), "active".to_string()], &rows1, true, ); fn check_one( sql: &str, expected_table_name: &str, expected_columns: &[String], expected_rows: &[Parens>], expected_value_keyword: bool, ) { match verified_stmt(sql) { Statement::Insert(Insert { table: table_name, columns, source: Some(source), .. }) => { assert_eq!(table_name.to_string(), expected_table_name); assert_eq!(columns.len(), expected_columns.len()); for (index, column) in columns.iter().enumerate() { assert_eq!( column, &ObjectName::from(Ident::new(expected_columns[index].clone())) ); } match *source.body { SetExpr::Values(Values { rows, value_keyword, .. }) => { assert_eq!(rows.as_slice(), expected_rows); assert!(value_keyword == expected_value_keyword); } _ => unreachable!(), } } _ => unreachable!(), } } verified_stmt("INSERT INTO customer WITH foo AS (SELECT 1) SELECT * FROM foo UNION VALUES (1)"); } #[test] fn parse_insert_set() { let dialects = all_dialects_where(|d| d.supports_insert_set()); dialects.verified_stmt("INSERT INTO tbl1 SET col1 = 1, col2 = 'abc', col3 = current_date()"); } #[test] fn parse_replace_into() { let dialect = PostgreSqlDialect {}; let sql = "REPLACE INTO public.customer (id, name, active) VALUES (1, 2, 3)"; assert_eq!( ParserError::ParserError("Unsupported statement REPLACE at Line: 1, Column: 9".to_string()), Parser::parse_sql(&dialect, sql,).unwrap_err(), ) } #[test] fn parse_insert_default_values() { let insert_with_default_values = verified_stmt("INSERT INTO test_table DEFAULT VALUES"); match insert_with_default_values { Statement::Insert(Insert { after_columns, columns, on, partitioned, returning, source, table: table_name, .. }) => { assert_eq!(columns, vec![]); assert_eq!(after_columns, vec![]); assert_eq!(on, None); assert_eq!(partitioned, None); assert_eq!(returning, None); assert_eq!(source, None); assert_eq!( table_name, TableObject::TableName(ObjectName::from(vec!["test_table".into()])) ); } _ => unreachable!(), } let insert_with_default_values_and_returning = verified_stmt("INSERT INTO test_table DEFAULT VALUES RETURNING test_column"); match insert_with_default_values_and_returning { Statement::Insert(Insert { after_columns, columns, on, partitioned, returning, source, table: table_name, .. }) => { assert_eq!(after_columns, vec![]); assert_eq!(columns, vec![]); assert_eq!(on, None); assert_eq!(partitioned, None); assert!(returning.is_some()); assert_eq!(source, None); assert_eq!( table_name, TableObject::TableName(ObjectName::from(vec!["test_table".into()])) ); } _ => unreachable!(), } let insert_with_default_values_and_on_conflict = verified_stmt("INSERT INTO test_table DEFAULT VALUES ON CONFLICT DO NOTHING"); match insert_with_default_values_and_on_conflict { Statement::Insert(Insert { after_columns, columns, on, partitioned, returning, source, table: table_name, .. }) => { assert_eq!(after_columns, vec![]); assert_eq!(columns, vec![]); assert!(on.is_some()); assert_eq!(partitioned, None); assert_eq!(returning, None); assert_eq!(source, None); assert_eq!( table_name, TableObject::TableName(ObjectName::from(vec!["test_table".into()])) ); } _ => unreachable!(), } let insert_with_columns_and_default_values = "INSERT INTO test_table (test_col) DEFAULT VALUES"; assert_eq!( ParserError::ParserError( "Expected: SELECT, VALUES, or a subquery in the query body, found: DEFAULT".to_string() ), parse_sql_statements(insert_with_columns_and_default_values).unwrap_err() ); let insert_with_default_values_and_hive_after_columns = "INSERT INTO test_table DEFAULT VALUES (some_column)"; assert_eq!( ParserError::ParserError("Expected: end of statement, found: (".to_string()), parse_sql_statements(insert_with_default_values_and_hive_after_columns).unwrap_err() ); let insert_with_default_values_and_hive_partition = "INSERT INTO test_table DEFAULT VALUES PARTITION (some_column)"; assert_eq!( ParserError::ParserError("Expected: end of statement, found: PARTITION".to_string()), parse_sql_statements(insert_with_default_values_and_hive_partition).unwrap_err() ); let insert_with_default_values_and_values_list = "INSERT INTO test_table DEFAULT VALUES (1)"; assert_eq!( ParserError::ParserError("Expected: end of statement, found: (".to_string()), parse_sql_statements(insert_with_default_values_and_values_list).unwrap_err() ); } #[test] fn parse_insert_select_returning() { // Dialects that support `RETURNING` as a column identifier do // not support this syntax. let dialects = all_dialects_where(|d| !d.is_column_alias(&Keyword::RETURNING, &mut Parser::new(d))); dialects.verified_stmt("INSERT INTO t SELECT 1 RETURNING 2"); let stmt = dialects.verified_stmt("INSERT INTO t SELECT x RETURNING x AS y"); match stmt { Statement::Insert(Insert { returning: Some(ret), source: Some(_), .. }) => assert_eq!(ret.len(), 1), _ => unreachable!(), } } #[test] fn parse_insert_select_from_returning() { let sql = "INSERT INTO table1 SELECT * FROM table2 RETURNING id"; match verified_stmt(sql) { Statement::Insert(Insert { table: TableObject::TableName(table_name), source: Some(source), returning: Some(returning), .. }) => { assert_eq!("table1", table_name.to_string()); assert!(matches!(*source.body, SetExpr::Select(_))); assert_eq!( returning, vec![SelectItem::UnnamedExpr(Expr::Identifier(Ident::new("id"))),] ); } bad_stmt => unreachable!("Expected valid insert, got {:?}", bad_stmt), } } #[test] fn parse_returning_as_column_alias() { verified_stmt("SELECT 1 AS RETURNING"); } #[test] fn parse_insert_sqlite() { let dialect = SQLiteDialect {}; let check = |sql: &str, expected_action: Option| match Parser::parse_sql( &dialect, sql, ) .unwrap() .pop() .unwrap() { Statement::Insert(Insert { or, .. }) => assert_eq!(or, expected_action), _ => panic!("{}", sql), }; let sql = "INSERT INTO test_table(id) VALUES(1)"; check(sql, None); let sql = "REPLACE INTO test_table(id) VALUES(1)"; check(sql, Some(SqliteOnConflict::Replace)); let sql = "INSERT OR REPLACE INTO test_table(id) VALUES(1)"; check(sql, Some(SqliteOnConflict::Replace)); let sql = "INSERT OR ROLLBACK INTO test_table(id) VALUES(1)"; check(sql, Some(SqliteOnConflict::Rollback)); let sql = "INSERT OR ABORT INTO test_table(id) VALUES(1)"; check(sql, Some(SqliteOnConflict::Abort)); let sql = "INSERT OR FAIL INTO test_table(id) VALUES(1)"; check(sql, Some(SqliteOnConflict::Fail)); let sql = "INSERT OR IGNORE INTO test_table(id) VALUES(1)"; check(sql, Some(SqliteOnConflict::Ignore)); } #[test] fn parse_update() { let sql = "UPDATE t SET a = 1, b = 2, c = 3 WHERE d"; match verified_stmt(sql) { Statement::Update(Update { table, assignments, selection, .. }) => { assert_eq!(table.to_string(), "t".to_string()); assert_eq!( assignments, vec![ Assignment { target: AssignmentTarget::ColumnName(ObjectName::from(vec!["a".into()])), value: Expr::value(number("1")), }, Assignment { target: AssignmentTarget::ColumnName(ObjectName::from(vec!["b".into()])), value: Expr::value(number("2")), }, Assignment { target: AssignmentTarget::ColumnName(ObjectName::from(vec!["c".into()])), value: Expr::value(number("3")), }, ] ); assert_eq!(selection.unwrap(), Expr::Identifier("d".into())); } _ => unreachable!(), } verified_stmt("UPDATE t SET a = 1, a = 2, a = 3"); let sql = "UPDATE t WHERE 1"; let res = parse_sql_statements(sql); assert_eq!( ParserError::ParserError("Expected: SET, found: WHERE".to_string()), res.unwrap_err() ); let sql = "UPDATE t SET a = 1 extrabadstuff"; let res = parse_sql_statements(sql); assert_eq!( ParserError::ParserError("Expected: end of statement, found: extrabadstuff".to_string()), res.unwrap_err() ); } #[test] fn parse_update_set_from() { let sql = "UPDATE t1 SET name = t2.name FROM (SELECT name, id FROM t1 GROUP BY id) AS t2 WHERE t1.id = t2.id"; let dialects = TestedDialects::new(vec![ Box::new(GenericDialect {}), Box::new(DuckDbDialect {}), Box::new(PostgreSqlDialect {}), Box::new(BigQueryDialect {}), Box::new(SnowflakeDialect {}), Box::new(RedshiftSqlDialect {}), Box::new(MsSqlDialect {}), Box::new(SQLiteDialect {}), ]); let stmt = dialects.verified_stmt(sql); assert_eq!( stmt, Statement::Update(Update { update_token: AttachedToken::empty(), optimizer_hints: vec![], table: TableWithJoins { relation: table_from_name(ObjectName::from(vec![Ident::new("t1")])), joins: vec![], }, assignments: vec![Assignment { target: AssignmentTarget::ColumnName(ObjectName::from(vec![Ident::new("name")])), value: Expr::CompoundIdentifier(vec![Ident::new("t2"), Ident::new("name")]) }], from: Some(UpdateTableFromKind::AfterSet(vec![TableWithJoins { relation: TableFactor::Derived { lateral: false, subquery: Box::new(Query { with: None, body: Box::new(SetExpr::Select(Box::new(Select { select_token: AttachedToken::empty(), optimizer_hints: vec![], distinct: None, select_modifiers: None, top: None, top_before_distinct: false, projection: vec![ SelectItem::UnnamedExpr(Expr::Identifier(Ident::new("name"))), SelectItem::UnnamedExpr(Expr::Identifier(Ident::new("id"))), ], exclude: None, into: None, from: vec![TableWithJoins { relation: table_from_name(ObjectName::from(vec![Ident::new("t1")])), joins: vec![], }], lateral_views: vec![], prewhere: None, selection: None, group_by: GroupByExpr::Expressions( vec![Expr::Identifier(Ident::new("id"))], vec![] ), cluster_by: vec![], distribute_by: vec![], sort_by: vec![], having: None, named_window: vec![], qualify: None, window_before_qualify: false, value_table_mode: None, connect_by: vec![], flavor: SelectFlavor::Standard, }))), order_by: None, limit_clause: None, fetch: None, locks: vec![], for_clause: None, settings: None, format_clause: None, pipe_operators: vec![], }), alias: table_alias(true, "t2"), sample: None, }, joins: vec![] }])), selection: Some(Expr::BinaryOp { left: Box::new(Expr::CompoundIdentifier(vec![ Ident::new("t1"), Ident::new("id") ])), op: BinaryOperator::Eq, right: Box::new(Expr::CompoundIdentifier(vec![ Ident::new("t2"), Ident::new("id") ])), }), returning: None, output: None, or: None, order_by: vec![], limit: None }) ); let sql = "UPDATE T SET a = b FROM U, (SELECT foo FROM V) AS W WHERE 1 = 1"; dialects.verified_stmt(sql); } #[test] fn parse_update_with_table_alias() { let sql = "UPDATE users AS u SET u.username = 'new_user' WHERE u.username = 'old_user'"; match verified_stmt(sql) { Statement::Update(Update { table, assignments, from: _from, selection, returning, or: None, order_by: _, limit: None, optimizer_hints, update_token: _, output: _, }) if optimizer_hints.is_empty() => { assert_eq!( TableWithJoins { relation: TableFactor::Table { name: ObjectName::from(vec![Ident::new("users")]), alias: table_alias(true, "u"), args: None, with_hints: vec![], version: None, partitions: vec![], with_ordinality: false, json_path: None, sample: None, index_hints: vec![], }, joins: vec![], }, table ); assert_eq!( vec![Assignment { target: AssignmentTarget::ColumnName(ObjectName::from(vec![ Ident::new("u"), Ident::new("username") ])), value: Expr::Value( (Value::SingleQuotedString("new_user".to_string())).with_empty_span() ), }], assignments ); assert_eq!( Some(Expr::BinaryOp { left: Box::new(Expr::CompoundIdentifier(vec![ Ident::new("u"), Ident::new("username"), ])), op: BinaryOperator::Eq, right: Box::new(Expr::Value( (Value::SingleQuotedString("old_user".to_string())).with_empty_span() )), }), selection ); assert_eq!(None, returning); } _ => unreachable!(), } } #[test] fn parse_update_or() { let expect_or_clause = |sql: &str, expected_action: SqliteOnConflict| match verified_stmt(sql) { Statement::Update(Update { or, .. }) => assert_eq!(or, Some(expected_action)), other => unreachable!("Expected update with or, got {:?}", other), }; expect_or_clause( "UPDATE OR REPLACE t SET n = n + 1", SqliteOnConflict::Replace, ); expect_or_clause( "UPDATE OR ROLLBACK t SET n = n + 1", SqliteOnConflict::Rollback, ); expect_or_clause("UPDATE OR ABORT t SET n = n + 1", SqliteOnConflict::Abort); expect_or_clause("UPDATE OR FAIL t SET n = n + 1", SqliteOnConflict::Fail); expect_or_clause("UPDATE OR IGNORE t SET n = n + 1", SqliteOnConflict::Ignore); } #[test] fn parse_select_with_table_alias_as() { one_statement_parses_to( "SELECT a, b, c FROM lineitem AS l (A, B, C)", "SELECT a, b, c FROM lineitem AS l (A, B, C)", ); // AS is optional one_statement_parses_to( "SELECT a, b, c FROM lineitem l (A, B, C)", "SELECT a, b, c FROM lineitem l (A, B, C)", ); } #[test] fn parse_select_with_table_alias() { let select = verified_only_select("SELECT a, b, c FROM lineitem AS l (A, B, C)"); assert_eq!( select.projection, vec![ SelectItem::UnnamedExpr(Expr::Identifier(Ident::new("a")),), SelectItem::UnnamedExpr(Expr::Identifier(Ident::new("b")),), SelectItem::UnnamedExpr(Expr::Identifier(Ident::new("c")),), ] ); assert_eq!( select.from, vec![TableWithJoins { relation: TableFactor::Table { name: ObjectName::from(vec![Ident::new("lineitem")]), alias: Some(TableAlias { explicit: true, name: Ident::new("l"), columns: vec![ TableAliasColumnDef::from_name("A"), TableAliasColumnDef::from_name("B"), TableAliasColumnDef::from_name("C"), ], at: None, }), args: None, with_hints: vec![], version: None, partitions: vec![], with_ordinality: false, json_path: None, sample: None, index_hints: vec![], }, joins: vec![], }] ); } #[test] fn parse_analyze() { verified_stmt("ANALYZE TABLE test_table"); verified_stmt("ANALYZE test_table"); } #[test] fn parse_invalid_table_name() { let ast = all_dialects().run_parser_method("db.public..customer", |parser| { parser.parse_object_name(false) }); assert!(ast.is_err()); } #[test] fn parse_no_table_name() { let ast = all_dialects().run_parser_method("", |parser| parser.parse_object_name(false)); assert!(ast.is_err()); } #[test] fn parse_delete_statement() { let sql = "DELETE FROM \"table\""; match verified_stmt(sql) { Statement::Delete(Delete { from: FromTable::WithFromKeyword(from), .. }) => { assert_eq!( table_from_name(ObjectName::from(vec![Ident::with_quote('"', "table")])), from[0].relation ); } _ => unreachable!(), } } #[test] fn parse_delete_without_from_error() { let sql = "DELETE \"table\" WHERE 1"; let dialects = all_dialects_except(|d| { d.is::() || d.is::() || d.is::() }); let res = dialects.parse_sql_statements(sql); assert_eq!( ParserError::ParserError("Expected: FROM, found: WHERE".to_string()), res.unwrap_err() ); } #[test] fn parse_delete_statement_for_multi_tables() { let sql = "DELETE schema1.table1, schema2.table2 FROM schema1.table1 JOIN schema2.table2 ON schema2.table2.col1 = schema1.table1.col1 WHERE schema2.table2.col2 = 1"; let dialects = all_dialects_except(|d| { d.is::() || d.is::() || d.is::() }); match dialects.verified_stmt(sql) { Statement::Delete(Delete { tables, from: FromTable::WithFromKeyword(from), .. }) => { assert_eq!( ObjectName::from(vec![Ident::new("schema1"), Ident::new("table1")]), tables[0] ); assert_eq!( ObjectName::from(vec![Ident::new("schema2"), Ident::new("table2")]), tables[1] ); assert_eq!( table_from_name(ObjectName::from(vec![ Ident::new("schema1"), Ident::new("table1") ])), from[0].relation ); assert_eq!( table_from_name(ObjectName::from(vec![ Ident::new("schema2"), Ident::new("table2") ])), from[0].joins[0].relation ); } _ => unreachable!(), } } #[test] fn parse_delete_statement_for_multi_tables_with_using() { let sql = "DELETE FROM schema1.table1, schema2.table2 USING schema1.table1 JOIN schema2.table2 ON schema2.table2.pk = schema1.table1.col1 WHERE schema2.table2.col2 = 1"; match verified_stmt(sql) { Statement::Delete(Delete { from: FromTable::WithFromKeyword(from), using: Some(using), .. }) => { assert_eq!( table_from_name(ObjectName::from(vec![ Ident::new("schema1"), Ident::new("table1") ])), from[0].relation ); assert_eq!( table_from_name(ObjectName::from(vec![ Ident::new("schema2"), Ident::new("table2") ])), from[1].relation ); assert_eq!( table_from_name(ObjectName::from(vec![ Ident::new("schema1"), Ident::new("table1") ])), using[0].relation ); assert_eq!( table_from_name(ObjectName::from(vec![ Ident::new("schema2"), Ident::new("table2") ])), using[0].joins[0].relation ); } _ => unreachable!(), } } #[test] fn parse_where_delete_statement() { use self::BinaryOperator::*; let sql = "DELETE FROM foo WHERE name = 5"; match verified_stmt(sql) { Statement::Delete(Delete { tables: _, from: FromTable::WithFromKeyword(from), using, selection, returning, .. }) => { assert_eq!( table_from_name(ObjectName::from(vec![Ident::new("foo")])), from[0].relation, ); assert_eq!(None, using); assert_eq!( Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("name"))), op: Eq, right: Box::new(Expr::value(number("5"))), }, selection.unwrap(), ); assert_eq!(None, returning); } _ => unreachable!(), } } #[test] fn parse_where_delete_with_alias_statement() { use self::BinaryOperator::*; let sql = "DELETE FROM basket AS a USING basket AS b WHERE a.id < b.id"; match verified_stmt(sql) { Statement::Delete(Delete { tables: _, from: FromTable::WithFromKeyword(from), using, selection, returning, .. }) => { assert_eq!( TableFactor::Table { name: ObjectName::from(vec![Ident::new("basket")]), alias: table_alias(true, "a"), args: None, with_hints: vec![], version: None, partitions: vec![], with_ordinality: false, json_path: None, sample: None, index_hints: vec![], }, from[0].relation, ); assert_eq!( Some(vec![TableWithJoins { relation: TableFactor::Table { name: ObjectName::from(vec![Ident::new("basket")]), alias: table_alias(true, "b"), args: None, with_hints: vec![], version: None, partitions: vec![], with_ordinality: false, json_path: None, sample: None, index_hints: vec![], }, joins: vec![], }]), using ); assert_eq!( Expr::BinaryOp { left: Box::new(Expr::CompoundIdentifier(vec![ Ident::new("a"), Ident::new("id"), ])), op: Lt, right: Box::new(Expr::CompoundIdentifier(vec![ Ident::new("b"), Ident::new("id"), ])), }, selection.unwrap(), ); assert_eq!(None, returning); } _ => unreachable!(), } } #[test] fn parse_top_level() { verified_stmt("SELECT 1"); verified_stmt("(SELECT 1)"); verified_stmt("((SELECT 1))"); verified_stmt("VALUES (1)"); verified_stmt("VALUES ROW(1, NULL, 'a'), ROW(2, NULL, 'b')"); } #[test] fn parse_simple_select() { let sql = "SELECT id, fname, lname FROM customer WHERE id = 1 LIMIT 5"; let select = verified_only_select(sql); assert!(select.distinct.is_none()); assert_eq!(3, select.projection.len()); let select = verified_query(sql); let expected_limit_clause = LimitClause::LimitOffset { limit: Some(Expr::value(number("5"))), offset: None, limit_by: vec![], }; assert_eq!(Some(expected_limit_clause), select.limit_clause); } #[test] fn parse_limit() { verified_stmt("SELECT * FROM user LIMIT 1"); } #[test] fn parse_invalid_limit_by() { all_dialects() .parse_sql_statements("SELECT * FROM user BY name") .expect_err("BY without LIMIT"); } #[test] fn parse_limit_is_not_an_alias() { // In dialects supporting LIMIT it shouldn't be parsed as a table alias let ast = verified_query("SELECT id FROM customer LIMIT 1"); let expected_limit_clause = LimitClause::LimitOffset { limit: Some(Expr::value(number("1"))), offset: None, limit_by: vec![], }; assert_eq!(Some(expected_limit_clause), ast.limit_clause); let ast = verified_query("SELECT 1 LIMIT 5"); let expected_limit_clause = LimitClause::LimitOffset { limit: Some(Expr::value(number("5"))), offset: None, limit_by: vec![], }; assert_eq!(Some(expected_limit_clause), ast.limit_clause); } #[test] fn parse_select_distinct() { let sql = "SELECT DISTINCT name FROM customer"; let select = verified_only_select(sql); assert!(select.distinct.is_some()); assert_eq!( &SelectItem::UnnamedExpr(Expr::Identifier(Ident::new("name"))), only(&select.projection) ); } #[test] fn parse_select_distinct_two_fields() { let sql = "SELECT DISTINCT name, id FROM customer"; let select = verified_only_select(sql); assert!(select.distinct.is_some()); assert_eq!( &SelectItem::UnnamedExpr(Expr::Identifier(Ident::new("name"))), &select.projection[0] ); assert_eq!( &SelectItem::UnnamedExpr(Expr::Identifier(Ident::new("id"))), &select.projection[1] ); } #[test] fn parse_select_distinct_tuple() { let sql = "SELECT DISTINCT (name, id) FROM customer"; let select = verified_only_select(sql); assert_eq!( &vec![SelectItem::UnnamedExpr(Expr::Tuple(vec![ Expr::Identifier(Ident::new("name")), Expr::Identifier(Ident::new("id")), ]))], &select.projection ); } #[test] fn parse_outer_join_operator() { let dialects = all_dialects_where(|d| d.supports_outer_join_operator()); let select = dialects.verified_only_select("SELECT 1 FROM T WHERE a = b (+)"); assert_eq!( select.selection, Some(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("a"))), op: BinaryOperator::Eq, right: Box::new(Expr::OuterJoin(Box::new(Expr::Identifier(Ident::new("b"))))) }) ); let select = dialects.verified_only_select("SELECT 1 FROM T WHERE t1.c1 = t2.c2.d3 (+)"); assert_eq!( select.selection, Some(Expr::BinaryOp { left: Box::new(Expr::CompoundIdentifier(vec![ Ident::new("t1"), Ident::new("c1") ])), op: BinaryOperator::Eq, right: Box::new(Expr::OuterJoin(Box::new(Expr::CompoundIdentifier(vec![ Ident::new("t2"), Ident::new("c2"), Ident::new("d3"), ])))) }) ); let res = dialects.parse_sql_statements("SELECT 1 FROM T WHERE 1 = 2 (+)"); assert_eq!( ParserError::ParserError("Expected: column identifier before (+), found: 2".to_string()), res.unwrap_err() ); } #[test] fn parse_select_distinct_on() { let sql = "SELECT DISTINCT ON (album_id) name FROM track ORDER BY album_id, milliseconds"; let select = all_dialects_except(|d| d.is::()).verified_only_select(sql); assert_eq!( &Some(Distinct::On(vec![Expr::Identifier(Ident::new("album_id"))])), &select.distinct ); let sql = "SELECT DISTINCT ON () name FROM track ORDER BY milliseconds"; let select = all_dialects_except(|d| d.is::()).verified_only_select(sql); assert_eq!(&Some(Distinct::On(vec![])), &select.distinct); let sql = "SELECT DISTINCT ON (album_id, milliseconds) name FROM track"; let select = all_dialects_except(|d| d.is::()).verified_only_select(sql); assert_eq!( &Some(Distinct::On(vec![ Expr::Identifier(Ident::new("album_id")), Expr::Identifier(Ident::new("milliseconds")), ])), &select.distinct ); } #[test] fn parse_select_distinct_missing_paren() { let result = parse_sql_statements("SELECT DISTINCT (name, id FROM customer"); assert_eq!( ParserError::ParserError("Expected: ), found: FROM".to_string()), result.unwrap_err(), ); } #[test] fn parse_select_all() { verified_stmt("SELECT ALL name FROM customer"); } #[test] fn parse_select_all_distinct() { let result = parse_sql_statements("SELECT ALL DISTINCT name FROM customer"); assert_eq!( ParserError::ParserError("Cannot specify ALL then DISTINCT".to_string()), result.unwrap_err(), ); let result = parse_sql_statements("SELECT DISTINCT ALL name FROM customer"); assert_eq!( ParserError::ParserError("Cannot specify DISTINCT then ALL".to_string()), result.unwrap_err(), ); let result = parse_sql_statements("SELECT ALL DISTINCT ON(name) name FROM customer"); assert_eq!( ParserError::ParserError("Cannot specify ALL then DISTINCT".to_string()), result.unwrap_err(), ); } #[test] fn parse_select_into() { let sql = "SELECT * INTO table0 FROM table1"; one_statement_parses_to(sql, "SELECT * INTO table0 FROM table1"); let select = verified_only_select(sql); assert_eq!( &SelectInto { temporary: false, unlogged: false, table: false, name: ObjectName::from(vec![Ident::new("table0")]), }, only(&select.into) ); let sql = "SELECT * INTO TEMPORARY UNLOGGED TABLE table0 FROM table1"; one_statement_parses_to( sql, "SELECT * INTO TEMPORARY UNLOGGED TABLE table0 FROM table1", ); // Do not allow aliases here let sql = "SELECT * INTO table0 asdf FROM table1"; let result = parse_sql_statements(sql); assert_eq!( ParserError::ParserError("Expected: end of statement, found: asdf".to_string()), result.unwrap_err() ) } #[test] fn parse_select_wildcard() { let sql = "SELECT * FROM foo"; let select = verified_only_select(sql); assert_eq!( &SelectItem::Wildcard(WildcardAdditionalOptions::default()), only(&select.projection) ); let sql = "SELECT foo.* FROM foo"; let select = verified_only_select(sql); assert_eq!( &SelectItem::QualifiedWildcard( SelectItemQualifiedWildcardKind::ObjectName(ObjectName::from(vec![Ident::new("foo")])), WildcardAdditionalOptions::default() ), only(&select.projection) ); let sql = "SELECT myschema.mytable.* FROM myschema.mytable"; let select = verified_only_select(sql); assert_eq!( &SelectItem::QualifiedWildcard( SelectItemQualifiedWildcardKind::ObjectName(ObjectName::from(vec![ Ident::new("myschema"), Ident::new("mytable"), ])), WildcardAdditionalOptions::default(), ), only(&select.projection) ); let sql = "SELECT * + * FROM foo;"; let result = parse_sql_statements(sql); assert_eq!( ParserError::ParserError("Expected: end of statement, found: +".to_string()), result.unwrap_err(), ); } #[test] fn parse_count_wildcard() { verified_only_select("SELECT COUNT(*) FROM Order WHERE id = 10"); verified_only_select( "SELECT COUNT(Employee.*) FROM Order JOIN Employee ON Order.employee = Employee.id", ); } #[test] fn parse_column_aliases() { let sql = "SELECT a.col + 1 AS newname FROM foo AS a"; let select = verified_only_select(sql); if let SelectItem::ExprWithAlias { expr: Expr::BinaryOp { ref op, ref right, .. }, ref alias, } = only(&select.projection) { assert_eq!(&BinaryOperator::Plus, op); assert_eq!(&Expr::value(number("1")), right.as_ref()); assert_eq!(&Ident::new("newname"), alias); } else { panic!("Expected: ExprWithAlias") } // alias without AS is parsed correctly: one_statement_parses_to("SELECT a.col + 1 newname FROM foo AS a", sql); } #[test] fn parse_select_expr_star() { let dialects = all_dialects_where(|d| d.supports_select_expr_star()); // Identifier wildcard expansion. let select = dialects.verified_only_select("SELECT foo.bar.* FROM T"); let SelectItem::QualifiedWildcard(SelectItemQualifiedWildcardKind::ObjectName(object_name), _) = only(&select.projection) else { unreachable!( "expected wildcard select item: got {:?}", &select.projection[0] ) }; assert_eq!( &ObjectName::from( ["foo", "bar"] .into_iter() .map(Ident::new) .collect::>() ), object_name ); // Arbitrary compound expression with wildcard expansion. let select = dialects.verified_only_select("SELECT foo - bar.* FROM T"); let SelectItem::QualifiedWildcard( SelectItemQualifiedWildcardKind::Expr(Expr::BinaryOp { left, op, right }), _, ) = only(&select.projection) else { unreachable!( "expected wildcard select item: got {:?}", &select.projection[0] ) }; let (Expr::Identifier(left), BinaryOperator::Minus, Expr::Identifier(right)) = (left.as_ref(), op, right.as_ref()) else { unreachable!("expected binary op expr: got {:?}", &select.projection[0]) }; assert_eq!(&Ident::new("foo"), left); assert_eq!(&Ident::new("bar"), right); // Arbitrary expression wildcard expansion. let select = dialects.verified_only_select("SELECT myfunc().foo.* FROM T"); let SelectItem::QualifiedWildcard( SelectItemQualifiedWildcardKind::Expr(Expr::CompoundFieldAccess { root, access_chain }), _, ) = only(&select.projection) else { unreachable!("expected wildcard expr: got {:?}", &select.projection[0]) }; assert!(matches!(root.as_ref(), Expr::Function(_))); assert_eq!(1, access_chain.len()); assert!(matches!( &access_chain[0], AccessExpr::Dot(Expr::Identifier(_)) )); dialects.one_statement_parses_to( "SELECT 2. * 3 FROM T", #[cfg(feature = "bigdecimal")] "SELECT 2 * 3 FROM T", #[cfg(not(feature = "bigdecimal"))] "SELECT 2. * 3 FROM T", ); dialects.verified_only_select("SELECT myfunc().* FROM T"); // Invalid let res = dialects.parse_sql_statements("SELECT foo.*.* FROM T"); assert_eq!( ParserError::ParserError("Expected: end of statement, found: .".to_string()), res.unwrap_err() ); let dialects = all_dialects_where(|d| { d.supports_select_expr_star() && d.supports_select_wildcard_except() }); dialects.verified_only_select("SELECT myfunc().* EXCEPT (foo) FROM T"); } #[test] fn parse_select_wildcard_with_alias() { let dialects = all_dialects_where(|d| d.supports_select_wildcard_with_alias()); // qualified wildcard with alias dialects .parse_sql_statements("SELECT t.* AS all_cols FROM t") .unwrap(); dialects.one_statement_parses_to( "SELECT t.* all_cols FROM t", "SELECT t.* AS all_cols FROM t", ); dialects.one_statement_parses_to( "SELECT t.* all_cols, other_col FROM t", "SELECT t.* AS all_cols, other_col FROM t", ); // unqualified wildcard with alias dialects .parse_sql_statements("SELECT * AS all_cols FROM t") .unwrap(); dialects.one_statement_parses_to("SELECT * all_cols FROM t", "SELECT * AS all_cols FROM t"); // mixed: regular column + qualified wildcard with alias dialects .parse_sql_statements("SELECT a.id, b.* AS b_cols FROM a JOIN b ON (a.id = b.a_id)") .unwrap(); dialects.one_statement_parses_to( "SELECT a.id, b.* b_cols FROM a JOIN b ON (a.id = b.a_id)", "SELECT a.id, b.* AS b_cols FROM a JOIN b ON (a.id = b.a_id)", ); } #[test] fn test_eof_after_as() { let res = parse_sql_statements("SELECT foo AS"); assert_eq!( ParserError::ParserError("Expected: an identifier after AS, found: EOF".to_string()), res.unwrap_err() ); let res = parse_sql_statements("SELECT 1 FROM foo AS"); assert_eq!( ParserError::ParserError("Expected: an identifier after AS, found: EOF".to_string()), res.unwrap_err() ); } #[test] fn test_no_infix_error() { let dialects = TestedDialects::new(vec![Box::new(ClickHouseDialect {})]); let res = dialects.parse_sql_statements("ASSERT-URA<<"); assert_eq!( ParserError::ParserError("No infix parser for token ShiftLeft".to_string()), res.unwrap_err() ); } #[test] fn parse_select_count_wildcard() { let sql = "SELECT COUNT(*) FROM customer"; let select = verified_only_select(sql); assert_eq!( &Expr::Function(Function { name: ObjectName::from(vec![Ident::new("COUNT")]), uses_odbc_syntax: false, parameters: FunctionArguments::None, args: FunctionArguments::List(FunctionArgumentList { duplicate_treatment: None, args: vec![FunctionArg::Unnamed(FunctionArgExpr::Wildcard)], clauses: vec![], }), null_treatment: None, filter: None, over: None, within_group: vec![] }), expr_from_projection(only(&select.projection)) ); } #[test] fn parse_select_count_distinct() { let sql = "SELECT COUNT(DISTINCT +x) FROM customer"; let select = verified_only_select(sql); assert_eq!( &Expr::Function(Function { name: ObjectName::from(vec![Ident::new("COUNT")]), uses_odbc_syntax: false, parameters: FunctionArguments::None, args: FunctionArguments::List(FunctionArgumentList { duplicate_treatment: Some(DuplicateTreatment::Distinct), args: vec![FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::UnaryOp { op: UnaryOperator::Plus, expr: Box::new(Expr::Identifier(Ident::new("x"))), }))], clauses: vec![], }), null_treatment: None, within_group: vec![], filter: None, over: None }), expr_from_projection(only(&select.projection)) ); verified_stmt("SELECT COUNT(ALL +x) FROM customer"); verified_stmt("SELECT COUNT(+x) FROM customer"); let sql = "SELECT COUNT(ALL DISTINCT + x) FROM customer"; let res = parse_sql_statements(sql); assert_eq!( ParserError::ParserError("Cannot specify both ALL and DISTINCT".to_string()), res.unwrap_err() ); } #[test] fn parse_not() { let sql = "SELECT id FROM customer WHERE NOT salary = ''"; let _ast = verified_only_select(sql); //TODO: add assertions } #[test] fn parse_invalid_infix_not() { let res = parse_sql_statements("SELECT c FROM t WHERE c NOT ("); assert_eq!( ParserError::ParserError("Expected: end of statement, found: NOT".to_string()), res.unwrap_err(), ); } #[test] fn parse_collate() { let sql = "SELECT name COLLATE \"de_DE\" FROM customer"; assert_matches!( only(&all_dialects().verified_only_select(sql).projection), SelectItem::UnnamedExpr(Expr::Collate { .. }) ); } #[test] fn parse_collate_after_parens() { let sql = "SELECT (name) COLLATE \"de_DE\" FROM customer"; assert_matches!( only(&all_dialects().verified_only_select(sql).projection), SelectItem::UnnamedExpr(Expr::Collate { .. }) ); } #[test] fn parse_select_string_predicate() { let sql = "SELECT id, fname, lname FROM customer \ WHERE salary <> 'Not Provided' AND salary <> ''"; let _ast = verified_only_select(sql); //TODO: add assertions } #[test] fn parse_projection_nested_type() { let sql = "SELECT customer.address.state FROM foo"; let _ast = verified_only_select(sql); //TODO: add assertions } #[test] fn parse_null_in_select() { let sql = "SELECT NULL"; let select = verified_only_select(sql); assert_eq!( &Expr::Value((Value::Null).with_empty_span()), expr_from_projection(only(&select.projection)), ); } #[test] fn parse_exponent_in_select() -> Result<(), ParserError> { // all except Hive, as it allows numbers to start an identifier let dialects = TestedDialects::new(vec![ Box::new(AnsiDialect {}), Box::new(BigQueryDialect {}), Box::new(ClickHouseDialect {}), Box::new(DuckDbDialect {}), Box::new(GenericDialect {}), // Box::new(HiveDialect {}), Box::new(MsSqlDialect {}), Box::new(MySqlDialect {}), Box::new(PostgreSqlDialect {}), Box::new(RedshiftSqlDialect {}), Box::new(SnowflakeDialect {}), Box::new(SQLiteDialect {}), ]); let sql = "SELECT 10e-20, 1e3, 1e+3, 1e3a, 1e, 0.5e2"; let mut select = dialects.parse_sql_statements(sql)?; let select = match select.pop().unwrap() { Statement::Query(inner) => *inner, _ => panic!("Expected: Query"), }; let select = match *select.body { SetExpr::Select(inner) => *inner, _ => panic!("Expected: SetExpr::Select"), }; assert_eq!( &vec![ SelectItem::UnnamedExpr(Expr::Value((number("10e-20")).with_empty_span())), SelectItem::UnnamedExpr(Expr::value(number("1e3"))), SelectItem::UnnamedExpr(Expr::Value((number("1e+3")).with_empty_span())), SelectItem::ExprWithAlias { expr: Expr::value(number("1e3")), alias: Ident::new("a") }, SelectItem::ExprWithAlias { expr: Expr::value(number("1")), alias: Ident::new("e") }, SelectItem::UnnamedExpr(Expr::value(number("0.5e2"))), ], &select.projection ); Ok(()) } #[test] fn parse_select_with_date_column_name() { let sql = "SELECT date"; let select = verified_only_select(sql); assert_eq!( &Expr::Identifier(Ident { value: "date".into(), quote_style: None, span: Span::empty(), }), expr_from_projection(only(&select.projection)), ); } #[test] fn parse_escaped_single_quote_string_predicate_with_escape() { use self::BinaryOperator::*; let sql = "SELECT id, fname, lname FROM customer \ WHERE salary <> 'Jim''s salary'"; let ast = verified_only_select(sql); assert_eq!( Some(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("salary"))), op: NotEq, right: Box::new(Expr::Value( (Value::SingleQuotedString("Jim's salary".to_string())).with_empty_span() )), }), ast.selection, ); } #[test] fn parse_escaped_single_quote_string_predicate_with_no_escape() { use self::BinaryOperator::*; let sql = "SELECT id, fname, lname FROM customer \ WHERE salary <> 'Jim''s salary'"; let ast = TestedDialects::new_with_options( vec![Box::new(MySqlDialect {})], ParserOptions::new() .with_trailing_commas(true) .with_unescape(false), ) .verified_only_select(sql); assert_eq!( Some(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("salary"))), op: NotEq, right: Box::new(Expr::Value( (Value::SingleQuotedString("Jim''s salary".to_string())).with_empty_span() )), }), ast.selection, ); } #[test] fn parse_number() { let expr = verified_expr("1.0"); #[cfg(feature = "bigdecimal")] assert_eq!( expr, Expr::Value((Value::Number(bigdecimal::BigDecimal::from(1), false)).with_empty_span()) ); #[cfg(not(feature = "bigdecimal"))] assert_eq!( expr, Expr::Value((Value::Number("1.0".into(), false)).with_empty_span()) ); } #[test] fn parse_compound_expr_1() { use self::BinaryOperator::*; use self::Expr::*; let sql = "a + b * c"; assert_eq!( BinaryOp { left: Box::new(Identifier(Ident::new("a"))), op: Plus, right: Box::new(BinaryOp { left: Box::new(Identifier(Ident::new("b"))), op: Multiply, right: Box::new(Identifier(Ident::new("c"))), }), }, verified_expr(sql) ); } #[test] fn parse_compound_expr_2() { use self::BinaryOperator::*; use self::Expr::*; let sql = "a * b + c"; assert_eq!( BinaryOp { left: Box::new(BinaryOp { left: Box::new(Identifier(Ident::new("a"))), op: Multiply, right: Box::new(Identifier(Ident::new("b"))), }), op: Plus, right: Box::new(Identifier(Ident::new("c"))), }, verified_expr(sql) ); } #[test] fn parse_unary_math_with_plus() { use self::Expr::*; let sql = "-a + -b"; assert_eq!( BinaryOp { left: Box::new(UnaryOp { op: UnaryOperator::Minus, expr: Box::new(Identifier(Ident::new("a"))), }), op: BinaryOperator::Plus, right: Box::new(UnaryOp { op: UnaryOperator::Minus, expr: Box::new(Identifier(Ident::new("b"))), }), }, verified_expr(sql) ); } #[test] fn parse_unary_math_with_multiply() { use self::Expr::*; let sql = "-a * -b"; assert_eq!( BinaryOp { left: Box::new(UnaryOp { op: UnaryOperator::Minus, expr: Box::new(Identifier(Ident::new("a"))), }), op: BinaryOperator::Multiply, right: Box::new(UnaryOp { op: UnaryOperator::Minus, expr: Box::new(Identifier(Ident::new("b"))), }), }, verified_expr(sql) ); } #[test] fn parse_mod() { use self::Expr::*; let sql = "a % b"; assert_eq!( BinaryOp { left: Box::new(Identifier(Ident::new("a"))), op: BinaryOperator::Modulo, right: Box::new(Identifier(Ident::new("b"))), }, verified_expr(sql) ); } fn pg_and_generic() -> TestedDialects { TestedDialects::new(vec![ Box::new(PostgreSqlDialect {}), Box::new(GenericDialect {}), ]) } fn ms_and_generic() -> TestedDialects { TestedDialects::new(vec![Box::new(MsSqlDialect {}), Box::new(GenericDialect {})]) } #[test] fn parse_json_ops_without_colon() { use self::BinaryOperator::*; let binary_ops = [ ( "->", Arrow, all_dialects_except(|d| d.supports_lambda_functions()), ), ("->", Arrow, pg_and_generic()), ("->>", LongArrow, all_dialects()), ("#>", HashArrow, pg_and_generic()), ("#>>", HashLongArrow, pg_and_generic()), ("@>", AtArrow, all_dialects()), ("<@", ArrowAt, all_dialects()), ("#-", HashMinus, pg_and_generic()), ("@?", AtQuestion, all_dialects()), ("@@", AtAt, all_dialects()), ]; for (str_op, op, dialects) in binary_ops { let select = dialects.verified_only_select(&format!("SELECT a {} b", &str_op)); assert_eq!( SelectItem::UnnamedExpr(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("a"))), op, right: Box::new(Expr::Identifier(Ident::new("b"))), }), select.projection[0] ); } } #[test] fn parse_json_object() { let dialects = TestedDialects::new(vec![ Box::new(MsSqlDialect {}), Box::new(PostgreSqlDialect {}), ]); let select = dialects.verified_only_select("SELECT JSON_OBJECT('name' : 'value', 'type' : 1)"); match expr_from_projection(&select.projection[0]) { Expr::Function(Function { args: FunctionArguments::List(FunctionArgumentList { args, .. }), .. }) => assert_eq!( &[ FunctionArg::ExprNamed { name: Expr::Value((Value::SingleQuotedString("name".into())).with_empty_span()), arg: FunctionArgExpr::Expr(Expr::Value( (Value::SingleQuotedString("value".into())).with_empty_span() )), operator: FunctionArgOperator::Colon }, FunctionArg::ExprNamed { name: Expr::Value((Value::SingleQuotedString("type".into())).with_empty_span()), arg: FunctionArgExpr::Expr(Expr::value(number("1"))), operator: FunctionArgOperator::Colon } ], &args[..] ), _ => unreachable!(), } let select = dialects .verified_only_select("SELECT JSON_OBJECT('name' : 'value', 'type' : NULL ABSENT ON NULL)"); match expr_from_projection(&select.projection[0]) { Expr::Function(Function { args: FunctionArguments::List(FunctionArgumentList { args, clauses, .. }), .. }) => { assert_eq!( &[ FunctionArg::ExprNamed { name: Expr::Value( (Value::SingleQuotedString("name".into())).with_empty_span() ), arg: FunctionArgExpr::Expr(Expr::Value( (Value::SingleQuotedString("value".into())).with_empty_span() )), operator: FunctionArgOperator::Colon }, FunctionArg::ExprNamed { name: Expr::Value( (Value::SingleQuotedString("type".into())).with_empty_span() ), arg: FunctionArgExpr::Expr(Expr::Value((Value::Null).with_empty_span())), operator: FunctionArgOperator::Colon } ], &args[..] ); assert_eq!( &[FunctionArgumentClause::JsonNullClause( JsonNullClause::AbsentOnNull )], &clauses[..] ); } _ => unreachable!(), } let select = dialects.verified_only_select("SELECT JSON_OBJECT(NULL ON NULL)"); match expr_from_projection(&select.projection[0]) { Expr::Function(Function { args: FunctionArguments::List(FunctionArgumentList { args, clauses, .. }), .. }) => { assert!(args.is_empty()); assert_eq!( &[FunctionArgumentClause::JsonNullClause( JsonNullClause::NullOnNull )], &clauses[..] ); } _ => unreachable!(), } let select = dialects.verified_only_select("SELECT JSON_OBJECT(ABSENT ON NULL)"); match expr_from_projection(&select.projection[0]) { Expr::Function(Function { args: FunctionArguments::List(FunctionArgumentList { args, clauses, .. }), .. }) => { assert!(args.is_empty()); assert_eq!( &[FunctionArgumentClause::JsonNullClause( JsonNullClause::AbsentOnNull )], &clauses[..] ); } _ => unreachable!(), } let select = dialects.verified_only_select( "SELECT JSON_OBJECT('name' : 'value', 'type' : JSON_ARRAY(1, 2) ABSENT ON NULL)", ); match expr_from_projection(&select.projection[0]) { Expr::Function(Function { args: FunctionArguments::List(FunctionArgumentList { args, clauses, .. }), .. }) => { assert_eq!( &FunctionArg::ExprNamed { name: Expr::Value((Value::SingleQuotedString("name".into())).with_empty_span()), arg: FunctionArgExpr::Expr(Expr::Value( (Value::SingleQuotedString("value".into())).with_empty_span() )), operator: FunctionArgOperator::Colon }, &args[0] ); assert!(matches!( args[1], FunctionArg::ExprNamed { name: Expr::Value(ValueWithSpan { value: Value::SingleQuotedString(_), span: _ }), arg: FunctionArgExpr::Expr(Expr::Function(_)), operator: FunctionArgOperator::Colon } )); assert_eq!( &[FunctionArgumentClause::JsonNullClause( JsonNullClause::AbsentOnNull )], &clauses[..] ); } _ => unreachable!(), } let select = dialects.verified_only_select( "SELECT JSON_OBJECT('name' : 'value', 'type' : JSON_OBJECT('type_id' : 1, 'name' : 'a') NULL ON NULL)", ); match expr_from_projection(&select.projection[0]) { Expr::Function(Function { args: FunctionArguments::List(FunctionArgumentList { args, clauses, .. }), .. }) => { assert_eq!( &FunctionArg::ExprNamed { name: Expr::Value((Value::SingleQuotedString("name".into())).with_empty_span()), arg: FunctionArgExpr::Expr(Expr::Value( (Value::SingleQuotedString("value".into())).with_empty_span() )), operator: FunctionArgOperator::Colon }, &args[0] ); assert!(matches!( args[1], FunctionArg::ExprNamed { name: Expr::Value(ValueWithSpan { value: Value::SingleQuotedString(_), span: _ }), arg: FunctionArgExpr::Expr(Expr::Function(_)), operator: FunctionArgOperator::Colon } )); assert_eq!( &[FunctionArgumentClause::JsonNullClause( JsonNullClause::NullOnNull )], &clauses[..] ); } _ => unreachable!(), } } #[test] fn parse_mod_no_spaces() { use self::Expr::*; let canonical = "a1 % b1"; let sqls = ["a1 % b1", "a1% b1", "a1 %b1", "a1%b1"]; for sql in sqls { println!("Parsing {sql}"); assert_eq!( BinaryOp { left: Box::new(Identifier(Ident::new("a1"))), op: BinaryOperator::Modulo, right: Box::new(Identifier(Ident::new("b1"))), }, pg_and_generic().expr_parses_to(sql, canonical) ); } } #[test] fn parse_is_null() { use self::Expr::*; let sql = "a IS NULL"; assert_eq!( IsNull(Box::new(Identifier(Ident::new("a")))), verified_expr(sql) ); } #[test] fn parse_is_not_null() { use self::Expr::*; let sql = "a IS NOT NULL"; assert_eq!( IsNotNull(Box::new(Identifier(Ident::new("a")))), verified_expr(sql) ); } #[test] fn parse_is_distinct_from() { use self::Expr::*; let sql = "a IS DISTINCT FROM b"; assert_eq!( IsDistinctFrom( Box::new(Identifier(Ident::new("a"))), Box::new(Identifier(Ident::new("b"))), ), verified_expr(sql) ); } #[test] fn parse_is_not_distinct_from() { use self::Expr::*; let sql = "a IS NOT DISTINCT FROM b"; assert_eq!( IsNotDistinctFrom( Box::new(Identifier(Ident::new("a"))), Box::new(Identifier(Ident::new("b"))), ), verified_expr(sql) ); } #[test] fn parse_not_precedence() { // NOT has higher precedence than OR/AND, so the following must parse as (NOT true) OR true let sql = "NOT 1 OR 1"; assert_matches!( verified_expr(sql), Expr::BinaryOp { op: BinaryOperator::Or, .. } ); // But NOT has lower precedence than comparison operators, so the following parses as NOT (a IS NULL) let sql = "NOT a IS NULL"; assert_matches!( verified_expr(sql), Expr::UnaryOp { op: UnaryOperator::Not, .. } ); // NOT has lower precedence than BETWEEN, so the following parses as NOT (1 NOT BETWEEN 1 AND 2) let sql = "NOT 1 NOT BETWEEN 1 AND 2"; assert_eq!( verified_expr(sql), Expr::UnaryOp { op: UnaryOperator::Not, expr: Box::new(Expr::Between { expr: Box::new(Expr::value(number("1"))), low: Box::new(Expr::value(number("1"))), high: Box::new(Expr::value(number("2"))), negated: true, }), }, ); // NOT has lower precedence than LIKE, so the following parses as NOT ('a' NOT LIKE 'b') let sql = "NOT 'a' NOT LIKE 'b'"; assert_eq!( verified_expr(sql), Expr::UnaryOp { op: UnaryOperator::Not, expr: Box::new(Expr::Like { expr: Box::new(Expr::Value( (Value::SingleQuotedString("a".into())).with_empty_span() )), negated: true, pattern: Box::new(Expr::Value( (Value::SingleQuotedString("b".into())).with_empty_span() )), escape_char: None, any: false, }), }, ); // NOT has lower precedence than IN, so the following parses as NOT (a NOT IN 'a') let sql = "NOT a NOT IN ('a')"; assert_eq!( verified_expr(sql), Expr::UnaryOp { op: UnaryOperator::Not, expr: Box::new(Expr::InList { expr: Box::new(Expr::Identifier("a".into())), list: vec![Expr::Value( (Value::SingleQuotedString("a".into())).with_empty_span() )], negated: true, }), }, ); } #[test] fn parse_null_like() { let sql = "SELECT \ column1 LIKE NULL AS col_null, \ NULL LIKE column1 AS null_col \ FROM customers"; let select = verified_only_select(sql); assert_eq!( SelectItem::ExprWithAlias { expr: Expr::Like { expr: Box::new(Expr::Identifier(Ident::new("column1"))), any: false, negated: false, pattern: Box::new(Expr::Value((Value::Null).with_empty_span())), escape_char: None, }, alias: Ident { value: "col_null".to_owned(), quote_style: None, span: Span::empty(), }, }, select.projection[0] ); assert_eq!( SelectItem::ExprWithAlias { expr: Expr::Like { expr: Box::new(Expr::Value((Value::Null).with_empty_span())), any: false, negated: false, pattern: Box::new(Expr::Identifier(Ident::new("column1"))), escape_char: None, }, alias: Ident { value: "null_col".to_owned(), quote_style: None, span: Span::empty(), }, }, select.projection[1] ); } #[test] fn parse_ilike() { fn chk(negated: bool) { let sql = &format!( "SELECT * FROM customers WHERE name {}ILIKE '%a'", if negated { "NOT " } else { "" } ); let select = verified_only_select(sql); assert_eq!( Expr::ILike { expr: Box::new(Expr::Identifier(Ident::new("name"))), negated, pattern: Box::new(Expr::Value( (Value::SingleQuotedString("%a".to_string())).with_empty_span() )), escape_char: None, any: false, }, select.selection.unwrap() ); // Test with escape char let sql = &format!( "SELECT * FROM customers WHERE name {}ILIKE '%a' ESCAPE '^'", if negated { "NOT " } else { "" } ); let select = verified_only_select(sql); assert_eq!( Expr::ILike { expr: Box::new(Expr::Identifier(Ident::new("name"))), negated, pattern: Box::new(Expr::Value( (Value::SingleQuotedString("%a".to_string())).with_empty_span() )), escape_char: Some(Value::SingleQuotedString('^'.to_string()).with_empty_span()), any: false, }, select.selection.unwrap() ); // This statement tests that ILIKE and NOT ILIKE have the same precedence. // This was previously mishandled (#81). let sql = &format!( "SELECT * FROM customers WHERE name {}ILIKE '%a' IS NULL", if negated { "NOT " } else { "" } ); let select = verified_only_select(sql); assert_eq!( Expr::IsNull(Box::new(Expr::ILike { expr: Box::new(Expr::Identifier(Ident::new("name"))), negated, pattern: Box::new(Expr::Value( (Value::SingleQuotedString("%a".to_string())).with_empty_span() )), escape_char: None, any: false, })), select.selection.unwrap() ); } chk(false); chk(true); } #[test] fn parse_like() { fn chk(negated: bool) { let sql = &format!( "SELECT * FROM customers WHERE name {}LIKE '%a'", if negated { "NOT " } else { "" } ); let select = verified_only_select(sql); assert_eq!( Expr::Like { expr: Box::new(Expr::Identifier(Ident::new("name"))), negated, pattern: Box::new(Expr::Value( (Value::SingleQuotedString("%a".to_string())).with_empty_span() )), escape_char: None, any: false, }, select.selection.unwrap() ); // Test with escape char let sql = &format!( "SELECT * FROM customers WHERE name {}LIKE '%a' ESCAPE '^'", if negated { "NOT " } else { "" } ); let select = verified_only_select(sql); assert_eq!( Expr::Like { expr: Box::new(Expr::Identifier(Ident::new("name"))), negated, pattern: Box::new(Expr::Value( (Value::SingleQuotedString("%a".to_string())).with_empty_span() )), escape_char: Some(Value::SingleQuotedString('^'.to_string()).with_empty_span()), any: false, }, select.selection.unwrap() ); // This statement tests that LIKE and NOT LIKE have the same precedence. // This was previously mishandled (#81). let sql = &format!( "SELECT * FROM customers WHERE name {}LIKE '%a' IS NULL", if negated { "NOT " } else { "" } ); let select = verified_only_select(sql); assert_eq!( Expr::IsNull(Box::new(Expr::Like { expr: Box::new(Expr::Identifier(Ident::new("name"))), negated, pattern: Box::new(Expr::Value( (Value::SingleQuotedString("%a".to_string())).with_empty_span() )), escape_char: None, any: false, })), select.selection.unwrap() ); } chk(false); chk(true); } #[test] fn parse_similar_to() { fn chk(negated: bool) { let sql = &format!( "SELECT * FROM customers WHERE name {}SIMILAR TO '%a'", if negated { "NOT " } else { "" } ); let select = verified_only_select(sql); assert_eq!( Expr::SimilarTo { expr: Box::new(Expr::Identifier(Ident::new("name"))), negated, pattern: Box::new(Expr::Value( (Value::SingleQuotedString("%a".to_string())).with_empty_span() )), escape_char: None, }, select.selection.unwrap() ); // Test with escape char let sql = &format!( "SELECT * FROM customers WHERE name {}SIMILAR TO '%a' ESCAPE '^'", if negated { "NOT " } else { "" } ); let select = verified_only_select(sql); assert_eq!( Expr::SimilarTo { expr: Box::new(Expr::Identifier(Ident::new("name"))), negated, pattern: Box::new(Expr::Value( (Value::SingleQuotedString("%a".to_string())).with_empty_span() )), escape_char: Some(Value::SingleQuotedString('^'.to_string()).with_empty_span()), }, select.selection.unwrap() ); let sql = &format!( "SELECT * FROM customers WHERE name {}SIMILAR TO '%a' ESCAPE NULL", if negated { "NOT " } else { "" } ); let select = verified_only_select(sql); assert_eq!( Expr::SimilarTo { expr: Box::new(Expr::Identifier(Ident::new("name"))), negated, pattern: Box::new(Expr::Value( (Value::SingleQuotedString("%a".to_string())).with_empty_span() )), escape_char: Some(Value::Null.with_empty_span()), }, select.selection.unwrap() ); // This statement tests that SIMILAR TO and NOT SIMILAR TO have the same precedence. let sql = &format!( "SELECT * FROM customers WHERE name {}SIMILAR TO '%a' ESCAPE '^' IS NULL", if negated { "NOT " } else { "" } ); let select = verified_only_select(sql); assert_eq!( Expr::IsNull(Box::new(Expr::SimilarTo { expr: Box::new(Expr::Identifier(Ident::new("name"))), negated, pattern: Box::new(Expr::Value( (Value::SingleQuotedString("%a".to_string())).with_empty_span() )), escape_char: Some(Value::SingleQuotedString('^'.to_string()).with_empty_span()), })), select.selection.unwrap() ); } chk(false); chk(true); } #[test] fn parse_in_list() { fn chk(negated: bool) { let sql = &format!( "SELECT * FROM customers WHERE segment {}IN ('HIGH', 'MED')", if negated { "NOT " } else { "" } ); let select = verified_only_select(sql); assert_eq!( Expr::InList { expr: Box::new(Expr::Identifier(Ident::new("segment"))), list: vec![ Expr::Value((Value::SingleQuotedString("HIGH".to_string())).with_empty_span()), Expr::Value((Value::SingleQuotedString("MED".to_string())).with_empty_span()), ], negated, }, select.selection.unwrap() ); } chk(false); chk(true); } #[test] fn parse_in_subquery() { let sql = "SELECT * FROM customers WHERE segment IN (SELECT segm FROM bar)"; let select = verified_only_select(sql); assert_eq!( Expr::InSubquery { expr: Box::new(Expr::Identifier(Ident::new("segment"))), subquery: Box::new(verified_query("SELECT segm FROM bar")), negated: false, }, select.selection.unwrap() ); } #[test] fn parse_in_union() { let sql = "SELECT * FROM customers WHERE segment IN ((SELECT segm FROM bar) UNION (SELECT segm FROM bar2))"; let select = verified_only_select(sql); assert_eq!( Expr::InSubquery { expr: Box::new(Expr::Identifier(Ident::new("segment"))), subquery: Box::new(verified_query( "(SELECT segm FROM bar) UNION (SELECT segm FROM bar2)" )), negated: false, }, select.selection.unwrap() ); } #[test] fn parse_in_unnest() { fn chk(negated: bool) { let sql = &format!( "SELECT * FROM customers WHERE segment {}IN UNNEST(expr)", if negated { "NOT " } else { "" } ); let select = verified_only_select(sql); assert_eq!( Expr::InUnnest { expr: Box::new(Expr::Identifier(Ident::new("segment"))), array_expr: Box::new(verified_expr("expr")), negated, }, select.selection.unwrap() ); } chk(false); chk(true); } #[test] fn parse_in_error() { // IN is no valid let sql = "SELECT * FROM customers WHERE segment in segment"; let res = parse_sql_statements(sql); assert_eq!( ParserError::ParserError("Expected: (, found: segment".to_string()), res.unwrap_err() ); } #[test] fn parse_string_agg() { let sql = "SELECT a || b"; let select = verified_only_select(sql); assert_eq!( SelectItem::UnnamedExpr(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("a"))), op: BinaryOperator::StringConcat, right: Box::new(Expr::Identifier(Ident::new("b"))), }), select.projection[0] ); } /// selects all dialects but PostgreSQL pub fn all_dialects_but_pg() -> TestedDialects { TestedDialects::new( all_dialects() .dialects .into_iter() .filter(|x| !x.is::()) .collect(), ) } #[test] fn parse_bitwise_ops() { let bitwise_ops = &[ ("^", BinaryOperator::BitwiseXor, all_dialects_but_pg()), ("|", BinaryOperator::BitwiseOr, all_dialects()), ("&", BinaryOperator::BitwiseAnd, all_dialects()), ]; for (str_op, op, dialects) in bitwise_ops { let select = dialects.verified_only_select(&format!("SELECT a {} b", &str_op)); assert_eq!( SelectItem::UnnamedExpr(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("a"))), op: op.clone(), right: Box::new(Expr::Identifier(Ident::new("b"))), }), select.projection[0] ); } } #[test] fn parse_bitwise_shift_ops() { let dialects = all_dialects_where(|d| d.supports_bitwise_shift_operators()); let sql = "SELECT 1 << 2, 3 >> 4"; let select = dialects.verified_only_select(sql); assert_eq!( SelectItem::UnnamedExpr(Expr::BinaryOp { left: Box::new(Expr::Value((number("1")).with_empty_span())), op: BinaryOperator::PGBitwiseShiftLeft, right: Box::new(Expr::Value((number("2")).with_empty_span())), }), select.projection[0] ); assert_eq!( SelectItem::UnnamedExpr(Expr::BinaryOp { left: Box::new(Expr::Value((number("3")).with_empty_span())), op: BinaryOperator::PGBitwiseShiftRight, right: Box::new(Expr::Value((number("4")).with_empty_span())), }), select.projection[1] ); } #[test] fn parse_binary_any() { let select = verified_only_select("SELECT a = ANY(b)"); assert_eq!( SelectItem::UnnamedExpr(Expr::AnyOp { left: Box::new(Expr::Identifier(Ident::new("a"))), compare_op: BinaryOperator::Eq, right: Box::new(Expr::Identifier(Ident::new("b"))), is_some: false, }), select.projection[0] ); } #[test] fn parse_binary_all() { let select = verified_only_select("SELECT a = ALL(b)"); assert_eq!( SelectItem::UnnamedExpr(Expr::AllOp { left: Box::new(Expr::Identifier(Ident::new("a"))), compare_op: BinaryOperator::Eq, right: Box::new(Expr::Identifier(Ident::new("b"))), }), select.projection[0] ); } #[test] fn parse_between() { fn chk(negated: bool) { let sql = &format!( "SELECT * FROM customers WHERE age {}BETWEEN 25 AND 32", if negated { "NOT " } else { "" } ); let select = verified_only_select(sql); assert_eq!( Expr::Between { expr: Box::new(Expr::Identifier(Ident::new("age"))), low: Box::new(Expr::value(number("25"))), high: Box::new(Expr::value(number("32"))), negated, }, select.selection.unwrap() ); } chk(false); chk(true); } #[test] fn parse_between_with_expr() { use self::BinaryOperator::*; let sql = "SELECT * FROM t WHERE 1 BETWEEN 1 + 2 AND 3 + 4 IS NULL"; let select = verified_only_select(sql); assert_eq!( Expr::IsNull(Box::new(Expr::Between { expr: Box::new(Expr::value(number("1"))), low: Box::new(Expr::BinaryOp { left: Box::new(Expr::value(number("1"))), op: Plus, right: Box::new(Expr::value(number("2"))), }), high: Box::new(Expr::BinaryOp { left: Box::new(Expr::value(number("3"))), op: Plus, right: Box::new(Expr::value(number("4"))), }), negated: false, })), select.selection.unwrap() ); let sql = "SELECT * FROM t WHERE 1 = 1 AND 1 + x BETWEEN 1 AND 2"; let select = verified_only_select(sql); assert_eq!( Expr::BinaryOp { left: Box::new(Expr::BinaryOp { left: Box::new(Expr::value(number("1"))), op: BinaryOperator::Eq, right: Box::new(Expr::value(number("1"))), }), op: BinaryOperator::And, right: Box::new(Expr::Between { expr: Box::new(Expr::BinaryOp { left: Box::new(Expr::value(number("1"))), op: BinaryOperator::Plus, right: Box::new(Expr::Identifier(Ident::new("x"))), }), low: Box::new(Expr::value(number("1"))), high: Box::new(Expr::value(number("2"))), negated: false, }), }, select.selection.unwrap(), ) } #[test] fn parse_tuples() { let sql = "SELECT (1, 2), (1), ('foo', 3, baz)"; let select = verified_only_select(sql); assert_eq!( vec![ SelectItem::UnnamedExpr(Expr::Tuple(vec![ Expr::value(number("1")), Expr::value(number("2")), ])), SelectItem::UnnamedExpr(Expr::Nested(Box::new(Expr::Value( (number("1")).with_empty_span() )))), SelectItem::UnnamedExpr(Expr::Tuple(vec![ Expr::Value((Value::SingleQuotedString("foo".into())).with_empty_span()), Expr::value(number("3")), Expr::Identifier(Ident::new("baz")), ])), ], select.projection ); } #[test] fn parse_tuple_invalid() { let sql = "select (1"; let res = parse_sql_statements(sql); assert_eq!( ParserError::ParserError("Expected: ), found: EOF".to_string()), res.unwrap_err() ); let sql = "select (), 2"; let res = parse_sql_statements(sql); assert_eq!( ParserError::ParserError("Expected: an expression, found: )".to_string()), res.unwrap_err() ); } #[test] fn parse_select_order_by() { fn chk(sql: &str) { let select = verified_query(sql); assert_eq!( OrderByKind::Expressions(vec![ OrderByExpr { expr: Expr::Identifier(Ident::new("lname")), options: OrderByOptions { asc: Some(true), nulls_first: None, }, with_fill: None, }, OrderByExpr { expr: Expr::Identifier(Ident::new("fname")), options: OrderByOptions { asc: Some(false), nulls_first: None, }, with_fill: None, }, OrderByExpr { expr: Expr::Identifier(Ident::new("id")), options: OrderByOptions { asc: None, nulls_first: None, }, with_fill: None, }, ]), select.order_by.expect("ORDER BY expected").kind ); } chk("SELECT id, fname, lname FROM customer WHERE id < 5 ORDER BY lname ASC, fname DESC, id"); // make sure ORDER is not treated as an alias chk("SELECT id, fname, lname FROM customer ORDER BY lname ASC, fname DESC, id"); chk("SELECT 1 AS lname, 2 AS fname, 3 AS id, 4 ORDER BY lname ASC, fname DESC, id"); } #[test] fn parse_select_order_by_limit() { let sql = "SELECT id, fname, lname FROM customer WHERE id < 5 \ ORDER BY lname ASC, fname DESC LIMIT 2"; let select = verified_query(sql); assert_eq!( OrderByKind::Expressions(vec![ OrderByExpr { expr: Expr::Identifier(Ident::new("lname")), options: OrderByOptions { asc: Some(true), nulls_first: None, }, with_fill: None, }, OrderByExpr { expr: Expr::Identifier(Ident::new("fname")), options: OrderByOptions { asc: Some(false), nulls_first: None, }, with_fill: None, }, ]), select.order_by.expect("ORDER BY expected").kind ); let expected_limit_clause = LimitClause::LimitOffset { limit: Some(Expr::value(number("2"))), offset: None, limit_by: vec![], }; assert_eq!(Some(expected_limit_clause), select.limit_clause); } #[test] fn parse_select_order_by_all() { fn chk(sql: &str, except_order_by: OrderByKind) { let dialects = all_dialects_where(|d| d.supports_order_by_all()); let select = dialects.verified_query(sql); assert_eq!( except_order_by, select.order_by.expect("ORDER BY expected").kind ); } let test_cases = [ ( "SELECT id, fname, lname FROM customer WHERE id < 5 ORDER BY ALL", OrderByKind::All(OrderByOptions { asc: None, nulls_first: None, }), ), ( "SELECT id, fname, lname FROM customer WHERE id < 5 ORDER BY ALL NULLS FIRST", OrderByKind::All(OrderByOptions { asc: None, nulls_first: Some(true), }), ), ( "SELECT id, fname, lname FROM customer WHERE id < 5 ORDER BY ALL NULLS LAST", OrderByKind::All(OrderByOptions { asc: None, nulls_first: Some(false), }), ), ( "SELECT id, fname, lname FROM customer ORDER BY ALL ASC", OrderByKind::All(OrderByOptions { asc: Some(true), nulls_first: None, }), ), ( "SELECT id, fname, lname FROM customer ORDER BY ALL ASC NULLS FIRST", OrderByKind::All(OrderByOptions { asc: Some(true), nulls_first: Some(true), }), ), ( "SELECT id, fname, lname FROM customer ORDER BY ALL ASC NULLS LAST", OrderByKind::All(OrderByOptions { asc: Some(true), nulls_first: Some(false), }), ), ( "SELECT id, fname, lname FROM customer WHERE id < 5 ORDER BY ALL DESC", OrderByKind::All(OrderByOptions { asc: Some(false), nulls_first: None, }), ), ( "SELECT id, fname, lname FROM customer WHERE id < 5 ORDER BY ALL DESC NULLS FIRST", OrderByKind::All(OrderByOptions { asc: Some(false), nulls_first: Some(true), }), ), ( "SELECT id, fname, lname FROM customer WHERE id < 5 ORDER BY ALL DESC NULLS LAST", OrderByKind::All(OrderByOptions { asc: Some(false), nulls_first: Some(false), }), ), ]; for (sql, expected_order_by) in test_cases { chk(sql, expected_order_by); } } #[test] fn parse_select_order_by_not_support_all() { fn chk(sql: &str, except_order_by: OrderByKind) { let dialects = all_dialects_where(|d| !d.supports_order_by_all()); let select = dialects.verified_query(sql); assert_eq!( except_order_by, select.order_by.expect("ORDER BY expected").kind ); } let test_cases = [ ( "SELECT id, ALL FROM customer WHERE id < 5 ORDER BY ALL", OrderByKind::Expressions(vec![OrderByExpr { expr: Expr::Identifier(Ident::new("ALL")), options: OrderByOptions { asc: None, nulls_first: None, }, with_fill: None, }]), ), ( "SELECT id, ALL FROM customer ORDER BY ALL ASC NULLS FIRST", OrderByKind::Expressions(vec![OrderByExpr { expr: Expr::Identifier(Ident::new("ALL")), options: OrderByOptions { asc: Some(true), nulls_first: Some(true), }, with_fill: None, }]), ), ( "SELECT id, ALL FROM customer ORDER BY ALL DESC NULLS LAST", OrderByKind::Expressions(vec![OrderByExpr { expr: Expr::Identifier(Ident::new("ALL")), options: OrderByOptions { asc: Some(false), nulls_first: Some(false), }, with_fill: None, }]), ), ]; for (sql, expected_order_by) in test_cases { chk(sql, expected_order_by); } } #[test] fn parse_select_order_by_nulls_order() { let sql = "SELECT id, fname, lname FROM customer WHERE id < 5 \ ORDER BY lname ASC NULLS FIRST, fname DESC NULLS LAST LIMIT 2"; let select = verified_query(sql); assert_eq!( OrderByKind::Expressions(vec![ OrderByExpr { expr: Expr::Identifier(Ident::new("lname")), options: OrderByOptions { asc: Some(true), nulls_first: Some(true), }, with_fill: None, }, OrderByExpr { expr: Expr::Identifier(Ident::new("fname")), options: OrderByOptions { asc: Some(false), nulls_first: Some(false), }, with_fill: None, }, ]), select.order_by.expect("ORDER BY expeccted").kind ); let expected_limit_clause = LimitClause::LimitOffset { limit: Some(Expr::value(number("2"))), offset: None, limit_by: vec![], }; assert_eq!(Some(expected_limit_clause), select.limit_clause); } #[test] fn parse_select_group_by() { let sql = "SELECT id, fname, lname FROM customer GROUP BY lname, fname"; let select = verified_only_select(sql); assert_eq!( GroupByExpr::Expressions( vec![ Expr::Identifier(Ident::new("lname")), Expr::Identifier(Ident::new("fname")), ], vec![] ), select.group_by ); // Tuples can also be in the set one_statement_parses_to( "SELECT id, fname, lname FROM customer GROUP BY (lname, fname)", "SELECT id, fname, lname FROM customer GROUP BY (lname, fname)", ); } #[test] fn parse_select_group_by_all() { let sql = "SELECT id, fname, lname, SUM(order) FROM customer GROUP BY ALL"; let select = verified_only_select(sql); assert_eq!(GroupByExpr::All(vec![]), select.group_by); one_statement_parses_to( "SELECT id, fname, lname, SUM(order) FROM customer GROUP BY ALL", "SELECT id, fname, lname, SUM(order) FROM customer GROUP BY ALL", ); } #[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], ]; let dialects = all_dialects_where(|d| d.supports_group_by_with_modifier()); 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 dialects.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 { dialects .parse_sql_statements(sql) .expect_err("Expected: one of ROLLUP or CUBE or TOTALS, found: WITH"); } } #[test] fn parse_group_by_special_grouping_sets() { let sql = "SELECT a, b, SUM(c) FROM tab1 GROUP BY a, b GROUPING SETS ((a, b), (a), (b), ())"; match all_dialects().verified_stmt(sql) { Statement::Query(query) => { let group_by = &query.body.as_select().unwrap().group_by; assert_eq!( group_by, &GroupByExpr::Expressions( vec![ Expr::Identifier(Ident::new("a")), Expr::Identifier(Ident::new("b")) ], vec![GroupByWithModifier::GroupingSets(Expr::GroupingSets(vec![ vec![ Expr::Identifier(Ident::new("a")), Expr::Identifier(Ident::new("b")) ], vec![Expr::Identifier(Ident::new("a")),], vec![Expr::Identifier(Ident::new("b"))], vec![] ]))] ) ); } _ => unreachable!(), } } #[test] fn parse_group_by_grouping_sets_single_values() { let sql = "SELECT a, b, SUM(c) FROM tab1 GROUP BY a, b GROUPING SETS ((a, b), a, (b), c, ())"; let canonical = "SELECT a, b, SUM(c) FROM tab1 GROUP BY a, b GROUPING SETS ((a, b), (a), (b), (c), ())"; match all_dialects().one_statement_parses_to(sql, canonical) { Statement::Query(query) => { let group_by = &query.body.as_select().unwrap().group_by; assert_eq!( group_by, &GroupByExpr::Expressions( vec![ Expr::Identifier(Ident::new("a")), Expr::Identifier(Ident::new("b")) ], vec![GroupByWithModifier::GroupingSets(Expr::GroupingSets(vec![ vec![ Expr::Identifier(Ident::new("a")), Expr::Identifier(Ident::new("b")) ], vec![Expr::Identifier(Ident::new("a"))], vec![Expr::Identifier(Ident::new("b"))], vec![Expr::Identifier(Ident::new("c"))], vec![] ]))] ) ); } _ => unreachable!(), } } #[test] fn parse_select_having() { let sql = "SELECT foo FROM bar GROUP BY foo HAVING COUNT(*) > 1"; let select = verified_only_select(sql); assert_eq!( Some(Expr::BinaryOp { left: Box::new(Expr::Function(Function { name: ObjectName::from(vec![Ident::new("COUNT")]), uses_odbc_syntax: false, parameters: FunctionArguments::None, args: FunctionArguments::List(FunctionArgumentList { duplicate_treatment: None, args: vec![FunctionArg::Unnamed(FunctionArgExpr::Wildcard)], clauses: vec![], }), null_treatment: None, filter: None, over: None, within_group: vec![] })), op: BinaryOperator::Gt, right: Box::new(Expr::value(number("1"))), }), select.having ); let sql = "SELECT 'foo' HAVING 1 = 1"; let select = verified_only_select(sql); assert!(select.having.is_some()); } #[test] fn parse_select_qualify() { let sql = "SELECT i, p, o FROM qt QUALIFY ROW_NUMBER() OVER (PARTITION BY p ORDER BY o) = 1"; let select = verified_only_select(sql); assert_eq!( Some(Expr::BinaryOp { left: Box::new(Expr::Function(Function { name: ObjectName::from(vec![Ident::new("ROW_NUMBER")]), uses_odbc_syntax: false, parameters: FunctionArguments::None, args: FunctionArguments::List(FunctionArgumentList { duplicate_treatment: None, args: vec![], clauses: vec![], }), null_treatment: None, filter: None, over: Some(WindowType::WindowSpec(WindowSpec { window_name: None, partition_by: vec![Expr::Identifier(Ident::new("p"))], order_by: vec![OrderByExpr { expr: Expr::Identifier(Ident::new("o")), options: OrderByOptions { asc: None, nulls_first: None, }, with_fill: None, }], window_frame: None, })), within_group: vec![] })), op: BinaryOperator::Eq, right: Box::new(Expr::value(number("1"))), }), select.qualify ); let sql = "SELECT i, p, o, ROW_NUMBER() OVER (PARTITION BY p ORDER BY o) AS row_num FROM qt QUALIFY row_num = 1"; let select = verified_only_select(sql); assert_eq!( Some(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("row_num"))), op: BinaryOperator::Eq, right: Box::new(Expr::value(number("1"))), }), select.qualify ); } #[test] fn parse_limit_accepts_all() { one_statement_parses_to( "SELECT id, fname, lname FROM customer WHERE id = 1 LIMIT ALL", "SELECT id, fname, lname FROM customer WHERE id = 1", ); one_statement_parses_to( "SELECT id, fname, lname FROM customer WHERE id = 1 LIMIT ALL OFFSET 1", "SELECT id, fname, lname FROM customer WHERE id = 1 OFFSET 1", ); one_statement_parses_to( "SELECT id, fname, lname FROM customer WHERE id = 1 OFFSET 1 LIMIT ALL", "SELECT id, fname, lname FROM customer WHERE id = 1 OFFSET 1", ); } #[test] fn parse_cast() { let sql = "SELECT CAST(id AS BIGINT) FROM customer"; let select = verified_only_select(sql); assert_eq!( &Expr::Cast { kind: CastKind::Cast, expr: Box::new(Expr::Identifier(Ident::new("id"))), data_type: DataType::BigInt(None), array: false, format: None, }, expr_from_projection(only(&select.projection)) ); let sql = "SELECT CAST(id AS TINYINT) FROM customer"; let select = verified_only_select(sql); assert_eq!( &Expr::Cast { kind: CastKind::Cast, expr: Box::new(Expr::Identifier(Ident::new("id"))), data_type: DataType::TinyInt(None), array: false, format: None, }, expr_from_projection(only(&select.projection)) ); one_statement_parses_to( "SELECT CAST(id AS MEDIUMINT) FROM customer", "SELECT CAST(id AS MEDIUMINT) FROM customer", ); one_statement_parses_to( "SELECT CAST(id AS BIGINT) FROM customer", "SELECT CAST(id AS BIGINT) FROM customer", ); verified_stmt("SELECT CAST(id AS NUMERIC) FROM customer"); verified_stmt("SELECT CAST(id AS DEC) FROM customer"); verified_stmt("SELECT CAST(id AS DECIMAL) FROM customer"); let sql = "SELECT CAST(id AS NVARCHAR(50)) FROM customer"; let select = verified_only_select(sql); assert_eq!( &Expr::Cast { kind: CastKind::Cast, expr: Box::new(Expr::Identifier(Ident::new("id"))), data_type: DataType::Nvarchar(Some(CharacterLength::IntegerLength { length: 50, unit: None, })), array: false, format: None, }, expr_from_projection(only(&select.projection)) ); let sql = "SELECT CAST(id AS CLOB) FROM customer"; let select = verified_only_select(sql); assert_eq!( &Expr::Cast { kind: CastKind::Cast, expr: Box::new(Expr::Identifier(Ident::new("id"))), data_type: DataType::Clob(None), array: false, format: None, }, expr_from_projection(only(&select.projection)) ); let sql = "SELECT CAST(id AS CLOB(50)) FROM customer"; let select = verified_only_select(sql); assert_eq!( &Expr::Cast { kind: CastKind::Cast, expr: Box::new(Expr::Identifier(Ident::new("id"))), data_type: DataType::Clob(Some(50)), array: false, format: None, }, expr_from_projection(only(&select.projection)) ); let sql = "SELECT CAST(id AS BINARY(50)) FROM customer"; let select = verified_only_select(sql); assert_eq!( &Expr::Cast { kind: CastKind::Cast, expr: Box::new(Expr::Identifier(Ident::new("id"))), data_type: DataType::Binary(Some(50)), array: false, format: None, }, expr_from_projection(only(&select.projection)) ); let sql = "SELECT CAST(id AS VARBINARY(50)) FROM customer"; let select = verified_only_select(sql); assert_eq!( &Expr::Cast { kind: CastKind::Cast, expr: Box::new(Expr::Identifier(Ident::new("id"))), data_type: DataType::Varbinary(Some(BinaryLength::IntegerLength { length: 50 })), array: false, format: None, }, expr_from_projection(only(&select.projection)) ); let sql = "SELECT CAST(id AS BLOB) FROM customer"; let select = verified_only_select(sql); assert_eq!( &Expr::Cast { kind: CastKind::Cast, expr: Box::new(Expr::Identifier(Ident::new("id"))), data_type: DataType::Blob(None), array: false, format: None, }, expr_from_projection(only(&select.projection)) ); let sql = "SELECT CAST(id AS BLOB(50)) FROM customer"; let select = verified_only_select(sql); assert_eq!( &Expr::Cast { kind: CastKind::Cast, expr: Box::new(Expr::Identifier(Ident::new("id"))), data_type: DataType::Blob(Some(50)), array: false, format: None, }, expr_from_projection(only(&select.projection)) ); let sql = "SELECT CAST(details AS JSONB) FROM customer"; let select = verified_only_select(sql); assert_eq!( &Expr::Cast { kind: CastKind::Cast, expr: Box::new(Expr::Identifier(Ident::new("details"))), data_type: DataType::JSONB, array: false, format: None, }, expr_from_projection(only(&select.projection)) ); } #[test] fn parse_try_cast() { let sql = "SELECT TRY_CAST(id AS BIGINT) FROM customer"; let select = verified_only_select(sql); assert_eq!( &Expr::Cast { kind: CastKind::TryCast, expr: Box::new(Expr::Identifier(Ident::new("id"))), data_type: DataType::BigInt(None), array: false, format: None, }, expr_from_projection(only(&select.projection)) ); verified_stmt("SELECT TRY_CAST(id AS BIGINT) FROM customer"); verified_stmt("SELECT TRY_CAST(id AS NUMERIC) FROM customer"); verified_stmt("SELECT TRY_CAST(id AS DEC) FROM customer"); verified_stmt("SELECT TRY_CAST(id AS DECIMAL) FROM customer"); } #[test] fn parse_extract() { let sql = "SELECT EXTRACT(YEAR FROM d)"; let select = verified_only_select(sql); assert_eq!( &Expr::Extract { field: DateTimeField::Year, syntax: ExtractSyntax::From, expr: Box::new(Expr::Identifier(Ident::new("d"))), }, expr_from_projection(only(&select.projection)), ); one_statement_parses_to("SELECT EXTRACT(year from d)", "SELECT EXTRACT(YEAR FROM d)"); verified_stmt("SELECT EXTRACT(MONTH FROM d)"); verified_stmt("SELECT EXTRACT(WEEK FROM d)"); verified_stmt("SELECT EXTRACT(DAY FROM d)"); verified_stmt("SELECT EXTRACT(DAYOFWEEK FROM d)"); verified_stmt("SELECT EXTRACT(DAYOFYEAR FROM d)"); verified_stmt("SELECT EXTRACT(DATE FROM d)"); verified_stmt("SELECT EXTRACT(DATETIME FROM d)"); verified_stmt("SELECT EXTRACT(HOUR FROM d)"); verified_stmt("SELECT EXTRACT(MINUTE FROM d)"); verified_stmt("SELECT EXTRACT(SECOND FROM d)"); verified_stmt("SELECT EXTRACT(MILLISECOND FROM d)"); verified_stmt("SELECT EXTRACT(MICROSECOND FROM d)"); verified_stmt("SELECT EXTRACT(NANOSECOND FROM d)"); verified_stmt("SELECT EXTRACT(CENTURY FROM d)"); verified_stmt("SELECT EXTRACT(DECADE FROM d)"); verified_stmt("SELECT EXTRACT(DOW FROM d)"); verified_stmt("SELECT EXTRACT(DOY FROM d)"); verified_stmt("SELECT EXTRACT(EPOCH FROM d)"); verified_stmt("SELECT EXTRACT(ISODOW FROM d)"); verified_stmt("SELECT EXTRACT(ISOWEEK FROM d)"); verified_stmt("SELECT EXTRACT(ISOYEAR FROM d)"); verified_stmt("SELECT EXTRACT(JULIAN FROM d)"); verified_stmt("SELECT EXTRACT(MICROSECOND FROM d)"); verified_stmt("SELECT EXTRACT(MICROSECONDS FROM d)"); verified_stmt("SELECT EXTRACT(MILLENIUM FROM d)"); verified_stmt("SELECT EXTRACT(MILLENNIUM FROM d)"); verified_stmt("SELECT EXTRACT(MILLISECOND FROM d)"); verified_stmt("SELECT EXTRACT(MILLISECONDS FROM d)"); verified_stmt("SELECT EXTRACT(QUARTER FROM d)"); verified_stmt("SELECT EXTRACT(TIMEZONE FROM d)"); verified_stmt("SELECT EXTRACT(TIMEZONE_ABBR FROM d)"); verified_stmt("SELECT EXTRACT(TIMEZONE_HOUR FROM d)"); verified_stmt("SELECT EXTRACT(TIMEZONE_MINUTE FROM d)"); verified_stmt("SELECT EXTRACT(TIMEZONE_REGION FROM d)"); verified_stmt("SELECT EXTRACT(TIME FROM d)"); let dialects = all_dialects_except(|d| d.allow_extract_custom()); let res = dialects.parse_sql_statements("SELECT EXTRACT(JIFFY FROM d)"); assert_eq!( ParserError::ParserError("Expected: date/time field, found: JIFFY".to_string()), res.unwrap_err() ); } #[test] fn parse_ceil_number() { verified_stmt("SELECT CEIL(1.5)"); verified_stmt("SELECT CEIL(float_column) FROM my_table"); } #[test] fn parse_floor_number() { verified_stmt("SELECT FLOOR(1.5)"); verified_stmt("SELECT FLOOR(float_column) FROM my_table"); } #[test] fn parse_ceil_number_scale() { verified_stmt("SELECT CEIL(1.5, 1)"); verified_stmt("SELECT CEIL(float_column, 3) FROM my_table"); } #[test] fn parse_floor_number_scale() { verified_stmt("SELECT FLOOR(1.5, 1)"); verified_stmt("SELECT FLOOR(float_column, 3) FROM my_table"); } #[test] fn parse_ceil_scale() { let sql = "SELECT CEIL(d, 2)"; let select = verified_only_select(sql); #[cfg(feature = "bigdecimal")] assert_eq!( &Expr::Ceil { expr: Box::new(Expr::Identifier(Ident::new("d"))), field: CeilFloorKind::Scale( Value::Number(bigdecimal::BigDecimal::from(2), false).with_empty_span() ), }, expr_from_projection(only(&select.projection)), ); #[cfg(not(feature = "bigdecimal"))] assert_eq!( &Expr::Ceil { expr: Box::new(Expr::Identifier(Ident::new("d"))), field: CeilFloorKind::Scale(Value::Number(2.to_string(), false).with_empty_span()), }, expr_from_projection(only(&select.projection)), ); } #[test] fn parse_floor_scale() { let sql = "SELECT FLOOR(d, 2)"; let select = verified_only_select(sql); #[cfg(feature = "bigdecimal")] assert_eq!( &Expr::Floor { expr: Box::new(Expr::Identifier(Ident::new("d"))), field: CeilFloorKind::Scale( Value::Number(bigdecimal::BigDecimal::from(2), false).with_empty_span() ), }, expr_from_projection(only(&select.projection)), ); #[cfg(not(feature = "bigdecimal"))] assert_eq!( &Expr::Floor { expr: Box::new(Expr::Identifier(Ident::new("d"))), field: CeilFloorKind::Scale(Value::Number(2.to_string(), false).with_empty_span()), }, expr_from_projection(only(&select.projection)), ); } #[test] fn parse_ceil_datetime() { let sql = "SELECT CEIL(d TO DAY)"; let select = verified_only_select(sql); assert_eq!( &Expr::Ceil { expr: Box::new(Expr::Identifier(Ident::new("d"))), field: CeilFloorKind::DateTimeField(DateTimeField::Day), }, expr_from_projection(only(&select.projection)), ); one_statement_parses_to("SELECT CEIL(d to day)", "SELECT CEIL(d TO DAY)"); verified_stmt("SELECT CEIL(d TO HOUR) FROM df"); verified_stmt("SELECT CEIL(d TO MINUTE) FROM df"); verified_stmt("SELECT CEIL(d TO SECOND) FROM df"); verified_stmt("SELECT CEIL(d TO MILLISECOND) FROM df"); let dialects = all_dialects_except(|d| d.allow_extract_custom()); let res = dialects.parse_sql_statements("SELECT CEIL(d TO JIFFY) FROM df"); assert_eq!( ParserError::ParserError("Expected: date/time field, found: JIFFY".to_string()), res.unwrap_err() ); } #[test] fn parse_floor_datetime() { let sql = "SELECT FLOOR(d TO DAY)"; let select = verified_only_select(sql); assert_eq!( &Expr::Floor { expr: Box::new(Expr::Identifier(Ident::new("d"))), field: CeilFloorKind::DateTimeField(DateTimeField::Day), }, expr_from_projection(only(&select.projection)), ); one_statement_parses_to("SELECT FLOOR(d to day)", "SELECT FLOOR(d TO DAY)"); verified_stmt("SELECT FLOOR(d TO HOUR) FROM df"); verified_stmt("SELECT FLOOR(d TO MINUTE) FROM df"); verified_stmt("SELECT FLOOR(d TO SECOND) FROM df"); verified_stmt("SELECT FLOOR(d TO MILLISECOND) FROM df"); let dialects = all_dialects_except(|d| d.allow_extract_custom()); let res = dialects.parse_sql_statements("SELECT FLOOR(d TO JIFFY) FROM df"); assert_eq!( ParserError::ParserError("Expected: date/time field, found: JIFFY".to_string()), res.unwrap_err() ); } #[test] fn parse_listagg() { let select = verified_only_select(concat!( "SELECT LISTAGG(DISTINCT dateid, ', ' ON OVERFLOW TRUNCATE '%' WITHOUT COUNT) ", "WITHIN GROUP (ORDER BY id, username)", )); assert_eq!( &Expr::Function(Function { name: ObjectName::from(vec![Ident::new("LISTAGG")]), uses_odbc_syntax: false, parameters: FunctionArguments::None, args: FunctionArguments::List(FunctionArgumentList { duplicate_treatment: Some(DuplicateTreatment::Distinct), args: vec![ FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::Identifier(Ident::new( "dateid" )))), FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::Value( (Value::SingleQuotedString(", ".to_owned())).with_empty_span() ))) ], clauses: vec![FunctionArgumentClause::OnOverflow( ListAggOnOverflow::Truncate { filler: Some(Box::new(Expr::Value( (Value::SingleQuotedString("%".to_string(),)).with_empty_span() ))), with_count: false, } )], }), filter: None, null_treatment: None, over: None, within_group: vec![ OrderByExpr { expr: Expr::Identifier(Ident { value: "id".to_string(), quote_style: None, span: Span::empty(), }), options: OrderByOptions { asc: None, nulls_first: None, }, with_fill: None, }, OrderByExpr { expr: Expr::Identifier(Ident { value: "username".to_string(), quote_style: None, span: Span::empty(), }), options: OrderByOptions { asc: None, nulls_first: None, }, with_fill: None, }, ] }), expr_from_projection(only(&select.projection)) ); verified_stmt("SELECT LISTAGG(sellerid) WITHIN GROUP (ORDER BY dateid)"); verified_stmt("SELECT LISTAGG(dateid)"); verified_stmt("SELECT LISTAGG(DISTINCT dateid)"); verified_stmt("SELECT LISTAGG(dateid ON OVERFLOW ERROR)"); verified_stmt("SELECT LISTAGG(dateid ON OVERFLOW TRUNCATE N'...' WITH COUNT)"); verified_stmt("SELECT LISTAGG(dateid ON OVERFLOW TRUNCATE X'deadbeef' WITH COUNT)"); } #[test] fn parse_array_agg_func() { let supported_dialects = TestedDialects::new(vec![ Box::new(GenericDialect {}), Box::new(DuckDbDialect {}), Box::new(PostgreSqlDialect {}), Box::new(MsSqlDialect {}), Box::new(AnsiDialect {}), Box::new(HiveDialect {}), ]); for sql in [ "SELECT ARRAY_AGG(x ORDER BY x) AS a FROM T", "SELECT ARRAY_AGG(x ORDER BY x LIMIT 2) FROM tbl", "SELECT ARRAY_AGG(DISTINCT x ORDER BY x LIMIT 2) FROM tbl", "SELECT ARRAY_AGG(x ORDER BY x, y) AS a FROM T", "SELECT ARRAY_AGG(x ORDER BY x ASC, y DESC) AS a FROM T", ] { supported_dialects.verified_stmt(sql); } } #[test] fn parse_agg_with_order_by() { let supported_dialects = TestedDialects::new(vec![ Box::new(GenericDialect {}), Box::new(PostgreSqlDialect {}), Box::new(MsSqlDialect {}), Box::new(AnsiDialect {}), Box::new(HiveDialect {}), ]); for sql in [ "SELECT FIRST_VALUE(x ORDER BY x) AS a FROM T", "SELECT FIRST_VALUE(x ORDER BY x) FROM tbl", "SELECT LAST_VALUE(x ORDER BY x, y) AS a FROM T", "SELECT LAST_VALUE(x ORDER BY x ASC, y DESC) AS a FROM T", ] { supported_dialects.verified_stmt(sql); } } #[test] fn parse_window_rank_function() { let supported_dialects = TestedDialects::new(vec![ Box::new(GenericDialect {}), Box::new(PostgreSqlDialect {}), Box::new(MsSqlDialect {}), Box::new(AnsiDialect {}), Box::new(HiveDialect {}), Box::new(SnowflakeDialect {}), ]); for sql in [ "SELECT column1, column2, FIRST_VALUE(column2) OVER (PARTITION BY column1 ORDER BY column2 NULLS LAST) AS column2_first FROM t1", "SELECT column1, column2, FIRST_VALUE(column2) OVER (ORDER BY column2 NULLS LAST) AS column2_first FROM t1", "SELECT col_1, col_2, LAG(col_2) OVER (ORDER BY col_1) FROM t1", "SELECT LAG(col_2, 1, 0) OVER (ORDER BY col_1) FROM t1", "SELECT LAG(col_2, 1, 0) OVER (PARTITION BY col_3 ORDER BY col_1)", ] { supported_dialects.verified_stmt(sql); } let supported_dialects_nulls = TestedDialects::new(vec![ Box::new(MsSqlDialect {}), Box::new(SnowflakeDialect {}), ]); for sql in [ "SELECT column1, column2, FIRST_VALUE(column2) IGNORE NULLS OVER (PARTITION BY column1 ORDER BY column2 NULLS LAST) AS column2_first FROM t1", "SELECT column1, column2, FIRST_VALUE(column2) RESPECT NULLS OVER (PARTITION BY column1 ORDER BY column2 NULLS LAST) AS column2_first FROM t1", "SELECT LAG(col_2, 1, 0) IGNORE NULLS OVER (ORDER BY col_1) FROM t1", "SELECT LAG(col_2, 1, 0) RESPECT NULLS OVER (ORDER BY col_1) FROM t1", ] { supported_dialects_nulls.verified_stmt(sql); } } #[test] fn parse_window_function_null_treatment_arg() { let dialects = all_dialects_where(|d| d.supports_window_function_null_treatment_arg()); let sql = "SELECT \ FIRST_VALUE(a IGNORE NULLS) OVER (), \ FIRST_VALUE(b RESPECT NULLS) OVER () \ FROM mytable"; let Select { projection, .. } = dialects.verified_only_select(sql); for (i, (expected_expr, expected_null_treatment)) in [ ("a", NullTreatment::IgnoreNulls), ("b", NullTreatment::RespectNulls), ] .into_iter() .enumerate() { let SelectItem::UnnamedExpr(Expr::Function(actual)) = &projection[i] else { unreachable!() }; assert_eq!( ObjectName::from(vec![Ident::new("FIRST_VALUE")]), actual.name ); let FunctionArguments::List(arg_list) = &actual.args else { panic!("expected argument list") }; assert!({ arg_list .clauses .iter() .all(|clause| !matches!(clause, FunctionArgumentClause::OrderBy(_))) }); assert_eq!(1, arg_list.args.len()); let FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::Identifier(actual_expr))) = &arg_list.args[0] else { unreachable!() }; assert_eq!(&Ident::new(expected_expr), actual_expr); assert_eq!( Some(expected_null_treatment), arg_list.clauses.iter().find_map(|clause| match clause { FunctionArgumentClause::IgnoreOrRespectNulls(nt) => Some(*nt), _ => None, }) ); } let sql = "SELECT LAG(1 IGNORE NULLS) IGNORE NULLS OVER () FROM t1"; assert_eq!( dialects.parse_sql_statements(sql).unwrap_err(), ParserError::ParserError("Expected: end of statement, found: NULLS".to_string()) ); let sql = "SELECT LAG(1 IGNORE NULLS) IGNORE NULLS OVER () FROM t1"; assert_eq!( all_dialects_where(|d| !d.supports_window_function_null_treatment_arg()) .parse_sql_statements(sql) .unwrap_err(), ParserError::ParserError("Expected: ), found: IGNORE".to_string()) ); } #[test] fn test_compound_expr() { let supported_dialects = TestedDialects::new(vec![ Box::new(GenericDialect {}), Box::new(DuckDbDialect {}), Box::new(BigQueryDialect {}), ]); let sqls = [ "SELECT abc[1].f1 FROM t", "SELECT abc[1].f1.f2 FROM t", "SELECT f1.abc[1] FROM t", "SELECT f1.f2.abc[1] FROM t", "SELECT f1.abc[1].f2 FROM t", "SELECT named_struct('a', 1, 'b', 2).a", "SELECT named_struct('a', 1, 'b', 2).a", "SELECT make_array(1, 2, 3)[1]", "SELECT make_array(named_struct('a', 1))[1].a", "SELECT abc[1][-1].a.b FROM t", "SELECT abc[1][-1].a.b[1] FROM t", ]; for sql in sqls { supported_dialects.verified_stmt(sql); } } #[test] fn test_double_value() { let dialects = all_dialects(); let test_cases = vec![ gen_number_case_with_sign("0."), gen_number_case_with_sign("0.0"), gen_number_case_with_sign("0000."), gen_number_case_with_sign("0000.00"), gen_number_case_with_sign(".0"), gen_number_case_with_sign(".00"), gen_number_case_with_sign("0e0"), gen_number_case_with_sign("0e+0"), gen_number_case_with_sign("0e-0"), gen_number_case_with_sign("0.e-0"), gen_number_case_with_sign("0.e+0"), gen_number_case_with_sign(".0e-0"), gen_number_case_with_sign(".0e+0"), gen_number_case_with_sign("00.0e+0"), gen_number_case_with_sign("00.0e-0"), ]; for (input, expected) in test_cases { for (i, expr) in input.iter().enumerate() { if let Statement::Query(query) = dialects.one_statement_parses_to(&format!("SELECT {expr}"), "") { if let SetExpr::Select(select) = *query.body { assert_eq!(expected[i], select.projection[0]); } else { panic!("Expected a SELECT statement"); } } else { panic!("Expected a SELECT statement"); } } } } fn gen_number_case(value: &str) -> (Vec, Vec) { let input = vec![ value.to_string(), format!("{} col_alias", value), format!("{} AS col_alias", value), ]; let expected = vec![ SelectItem::UnnamedExpr(Expr::value(number(value))), SelectItem::ExprWithAlias { expr: Expr::value(number(value)), alias: Ident::new("col_alias"), }, SelectItem::ExprWithAlias { expr: Expr::value(number(value)), alias: Ident::new("col_alias"), }, ]; (input, expected) } fn gen_sign_number_case(value: &str, op: UnaryOperator) -> (Vec, Vec) { match op { UnaryOperator::Plus | UnaryOperator::Minus => {} _ => panic!("Invalid sign"), } let input = vec![ format!("{}{}", op, value), format!("{}{} col_alias", op, value), format!("{}{} AS col_alias", op, value), ]; let expected = vec![ SelectItem::UnnamedExpr(Expr::UnaryOp { op, expr: Box::new(Expr::value(number(value))), }), SelectItem::ExprWithAlias { expr: Expr::UnaryOp { op, expr: Box::new(Expr::value(number(value))), }, alias: Ident::new("col_alias"), }, SelectItem::ExprWithAlias { expr: Expr::UnaryOp { op, expr: Box::new(Expr::value(number(value))), }, alias: Ident::new("col_alias"), }, ]; (input, expected) } /// generate the test cases for signed and unsigned numbers /// For example, given "0.0", the test cases will be: /// - "0.0" /// - "+0.0" /// - "-0.0" fn gen_number_case_with_sign(number: &str) -> (Vec, Vec) { let (mut input, mut expected) = gen_number_case(number); for op in [UnaryOperator::Plus, UnaryOperator::Minus] { let (input_sign, expected_sign) = gen_sign_number_case(number, op); input.extend(input_sign); expected.extend(expected_sign); } (input, expected) } #[test] fn parse_negative_value() { let sql1 = "SELECT -1"; one_statement_parses_to(sql1, "SELECT -1"); let sql2 = "CREATE SEQUENCE name INCREMENT -10 MINVALUE -1000 MAXVALUE 15 START -100;"; one_statement_parses_to( sql2, "CREATE SEQUENCE name INCREMENT -10 MINVALUE -1000 MAXVALUE 15 START -100", ); } #[test] fn parse_create_table() { let sql = "CREATE TABLE uk_cities (\ name VARCHAR(100) NOT NULL,\ lat DOUBLE NULL,\ lng DOUBLE, constrained INT NULL CONSTRAINT pkey PRIMARY KEY NOT NULL UNIQUE CHECK (constrained > 0), ref INT REFERENCES othertable (a, b),\ ref2 INT references othertable2 on delete cascade on update no action,\ constraint fkey foreign key (lat) references othertable3 (lat) on delete restrict,\ constraint fkey2 foreign key (lat) references othertable4(lat) on delete no action on update restrict, \ foreign key (lat) references othertable4(lat) on update set default on delete cascade, \ FOREIGN KEY (lng) REFERENCES othertable4 (longitude) ON UPDATE SET NULL )"; let ast = one_statement_parses_to( sql, "CREATE TABLE uk_cities (\ name VARCHAR(100) NOT NULL, \ lat DOUBLE NULL, \ lng DOUBLE, \ constrained INT NULL CONSTRAINT pkey PRIMARY KEY NOT NULL UNIQUE CHECK (constrained > 0), \ ref INT REFERENCES othertable (a, b), \ ref2 INT REFERENCES othertable2 ON DELETE CASCADE ON UPDATE NO ACTION, \ CONSTRAINT fkey FOREIGN KEY (lat) REFERENCES othertable3(lat) ON DELETE RESTRICT, \ CONSTRAINT fkey2 FOREIGN KEY (lat) REFERENCES othertable4(lat) ON DELETE NO ACTION ON UPDATE RESTRICT, \ FOREIGN KEY (lat) REFERENCES othertable4(lat) ON DELETE CASCADE ON UPDATE SET DEFAULT, \ FOREIGN KEY (lng) REFERENCES othertable4(longitude) ON UPDATE SET NULL)", ); match ast { Statement::CreateTable(CreateTable { name, columns, constraints, table_options, if_not_exists: false, external: false, file_format: None, location: None, .. }) => { assert_eq!("uk_cities", name.to_string()); assert_eq!( columns, vec![ ColumnDef { name: "name".into(), data_type: DataType::Varchar(Some(CharacterLength::IntegerLength { length: 100, unit: None, })), options: vec![ColumnOptionDef { name: None, option: ColumnOption::NotNull, }], }, ColumnDef { name: "lat".into(), data_type: DataType::Double(ExactNumberInfo::None), options: vec![ColumnOptionDef { name: None, option: ColumnOption::Null, }], }, ColumnDef { name: "lng".into(), data_type: DataType::Double(ExactNumberInfo::None), options: vec![], }, ColumnDef { name: "constrained".into(), data_type: DataType::Int(None), options: vec![ ColumnOptionDef { name: None, option: ColumnOption::Null, }, ColumnOptionDef { name: Some("pkey".into()), option: ColumnOption::PrimaryKey(PrimaryKeyConstraint { name: None, index_name: None, index_type: None, columns: vec![], index_options: vec![], characteristics: None, }), }, ColumnOptionDef { name: None, option: ColumnOption::NotNull, }, ColumnOptionDef { name: None, option: ColumnOption::Unique(UniqueConstraint { name: None, index_name: None, index_type_display: KeyOrIndexDisplay::None, index_type: None, columns: vec![], index_options: vec![], characteristics: None, nulls_distinct: NullsDistinctOption::None, }), }, ColumnOptionDef { name: None, option: ColumnOption::Check(CheckConstraint { name: None, expr: Box::new(verified_expr("constrained > 0")), enforced: None, }), }, ], }, ColumnDef { name: "ref".into(), data_type: DataType::Int(None), options: vec![ColumnOptionDef { name: None, option: ColumnOption::ForeignKey(ForeignKeyConstraint { name: None, index_name: None, columns: vec![], foreign_table: ObjectName::from(vec!["othertable".into()]), referred_columns: vec!["a".into(), "b".into()], on_delete: None, on_update: None, match_kind: None, characteristics: None, }), }], }, ColumnDef { name: "ref2".into(), data_type: DataType::Int(None), options: vec![ColumnOptionDef { name: None, option: ColumnOption::ForeignKey(ForeignKeyConstraint { name: None, index_name: None, columns: vec![], foreign_table: ObjectName::from(vec!["othertable2".into()]), referred_columns: vec![], on_delete: Some(ReferentialAction::Cascade), on_update: Some(ReferentialAction::NoAction), match_kind: None, characteristics: None, }), },], }, ] ); assert_eq!( constraints, vec![ ForeignKeyConstraint { name: Some("fkey".into()), index_name: None, columns: vec!["lat".into()], foreign_table: ObjectName::from(vec!["othertable3".into()]), referred_columns: vec!["lat".into()], on_delete: Some(ReferentialAction::Restrict), on_update: None, match_kind: None, characteristics: None, } .into(), ForeignKeyConstraint { name: Some("fkey2".into()), index_name: None, columns: vec!["lat".into()], foreign_table: ObjectName::from(vec!["othertable4".into()]), referred_columns: vec!["lat".into()], on_delete: Some(ReferentialAction::NoAction), on_update: Some(ReferentialAction::Restrict), match_kind: None, characteristics: None, } .into(), ForeignKeyConstraint { name: None, index_name: None, columns: vec!["lat".into()], foreign_table: ObjectName::from(vec!["othertable4".into()]), referred_columns: vec!["lat".into()], on_delete: Some(ReferentialAction::Cascade), on_update: Some(ReferentialAction::SetDefault), match_kind: None, characteristics: None, } .into(), ForeignKeyConstraint { name: None, index_name: None, columns: vec!["lng".into()], foreign_table: ObjectName::from(vec!["othertable4".into()]), referred_columns: vec!["longitude".into()], on_delete: None, on_update: Some(ReferentialAction::SetNull), match_kind: None, characteristics: None, } .into(), ] ); assert_eq!(table_options, CreateTableOptions::None); } _ => unreachable!(), } let res = parse_sql_statements("CREATE TABLE t (a int NOT NULL GARBAGE)"); assert!(res .unwrap_err() .to_string() .contains("Expected: \',\' or \')\' after column definition, found: GARBAGE")); let res = parse_sql_statements("CREATE TABLE t (a int NOT NULL CONSTRAINT foo)"); assert!(res .unwrap_err() .to_string() .contains("Expected: constraint details after CONSTRAINT ")); } #[test] fn parse_create_table_with_constraint_characteristics() { let sql = "CREATE TABLE uk_cities (\ name VARCHAR(100) NOT NULL,\ lat DOUBLE NULL,\ lng DOUBLE, constraint fkey foreign key (lat) references othertable3 (lat) on delete restrict deferrable initially deferred,\ constraint fkey2 foreign key (lat) references othertable4(lat) on delete no action on update restrict deferrable initially immediate, \ foreign key (lat) references othertable4(lat) on update set default on delete cascade not deferrable initially deferred not enforced, \ FOREIGN KEY (lng) REFERENCES othertable4 (longitude) ON UPDATE SET NULL enforced not deferrable initially immediate )"; let ast = one_statement_parses_to( sql, "CREATE TABLE uk_cities (\ name VARCHAR(100) NOT NULL, \ lat DOUBLE NULL, \ lng DOUBLE, \ CONSTRAINT fkey FOREIGN KEY (lat) REFERENCES othertable3(lat) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED, \ CONSTRAINT fkey2 FOREIGN KEY (lat) REFERENCES othertable4(lat) ON DELETE NO ACTION ON UPDATE RESTRICT DEFERRABLE INITIALLY IMMEDIATE, \ FOREIGN KEY (lat) REFERENCES othertable4(lat) ON DELETE CASCADE ON UPDATE SET DEFAULT NOT DEFERRABLE INITIALLY DEFERRED NOT ENFORCED, \ FOREIGN KEY (lng) REFERENCES othertable4(longitude) ON UPDATE SET NULL NOT DEFERRABLE INITIALLY IMMEDIATE ENFORCED)", ); match ast { Statement::CreateTable(CreateTable { name, columns, constraints, table_options, if_not_exists: false, external: false, file_format: None, location: None, .. }) => { assert_eq!("uk_cities", name.to_string()); assert_eq!( columns, vec![ ColumnDef { name: "name".into(), data_type: DataType::Varchar(Some(CharacterLength::IntegerLength { length: 100, unit: None, })), options: vec![ColumnOptionDef { name: None, option: ColumnOption::NotNull, }], }, ColumnDef { name: "lat".into(), data_type: DataType::Double(ExactNumberInfo::None), options: vec![ColumnOptionDef { name: None, option: ColumnOption::Null, }], }, ColumnDef { name: "lng".into(), data_type: DataType::Double(ExactNumberInfo::None), options: vec![], }, ] ); assert_eq!( constraints, vec![ ForeignKeyConstraint { name: Some("fkey".into()), index_name: None, columns: vec!["lat".into()], foreign_table: ObjectName::from(vec!["othertable3".into()]), referred_columns: vec!["lat".into()], on_delete: Some(ReferentialAction::Restrict), on_update: None, match_kind: None, characteristics: Some(ConstraintCharacteristics { deferrable: Some(true), initially: Some(DeferrableInitial::Deferred), enforced: None }), } .into(), ForeignKeyConstraint { name: Some("fkey2".into()), index_name: None, columns: vec!["lat".into()], foreign_table: ObjectName::from(vec!["othertable4".into()]), referred_columns: vec!["lat".into()], on_delete: Some(ReferentialAction::NoAction), on_update: Some(ReferentialAction::Restrict), match_kind: None, characteristics: Some(ConstraintCharacteristics { deferrable: Some(true), initially: Some(DeferrableInitial::Immediate), enforced: None, }), } .into(), ForeignKeyConstraint { name: None, index_name: None, columns: vec!["lat".into()], foreign_table: ObjectName::from(vec!["othertable4".into()]), referred_columns: vec!["lat".into()], on_delete: Some(ReferentialAction::Cascade), on_update: Some(ReferentialAction::SetDefault), match_kind: None, characteristics: Some(ConstraintCharacteristics { deferrable: Some(false), initially: Some(DeferrableInitial::Deferred), enforced: Some(false), }), } .into(), ForeignKeyConstraint { name: None, index_name: None, columns: vec!["lng".into()], foreign_table: ObjectName::from(vec!["othertable4".into()]), referred_columns: vec!["longitude".into()], on_delete: None, on_update: Some(ReferentialAction::SetNull), match_kind: None, characteristics: Some(ConstraintCharacteristics { deferrable: Some(false), initially: Some(DeferrableInitial::Immediate), enforced: Some(true), }), } .into(), ] ); assert_eq!(table_options, CreateTableOptions::None); } _ => unreachable!(), } let res = parse_sql_statements("CREATE TABLE t ( a int NOT NULL, FOREIGN KEY (a) REFERENCES othertable4(a) ON DELETE CASCADE ON UPDATE SET DEFAULT DEFERRABLE INITIALLY IMMEDIATE NOT DEFERRABLE, \ )"); assert!(res .unwrap_err() .to_string() .contains("Expected: \',\' or \')\' after column definition, found: NOT")); let res = parse_sql_statements("CREATE TABLE t ( a int NOT NULL, FOREIGN KEY (a) REFERENCES othertable4(a) ON DELETE CASCADE ON UPDATE SET DEFAULT NOT ENFORCED INITIALLY DEFERRED ENFORCED, \ )"); assert!(res .unwrap_err() .to_string() .contains("Expected: \',\' or \')\' after column definition, found: ENFORCED")); let res = parse_sql_statements("CREATE TABLE t ( a int NOT NULL, FOREIGN KEY (lat) REFERENCES othertable4(lat) ON DELETE CASCADE ON UPDATE SET DEFAULT INITIALLY DEFERRED INITIALLY IMMEDIATE, \ )"); assert!(res .unwrap_err() .to_string() .contains("Expected: \',\' or \')\' after column definition, found: INITIALLY")); } #[test] fn parse_create_table_column_constraint_characteristics() { fn test_combo( syntax: &str, deferrable: Option, initially: Option, enforced: Option, ) { let message = if syntax.is_empty() { "No clause" } else { syntax }; let sql = format!("CREATE TABLE t (a int UNIQUE {syntax})"); let expected_clause = if syntax.is_empty() { String::new() } else { format!(" {syntax}") }; let expected = format!("CREATE TABLE t (a INT UNIQUE{expected_clause})"); let ast = one_statement_parses_to(&sql, &expected); let expected_value = if deferrable.is_some() || initially.is_some() || enforced.is_some() { Some(ConstraintCharacteristics { deferrable, initially, enforced, }) } else { None }; match ast { Statement::CreateTable(CreateTable { columns, .. }) => { assert_eq!( columns, vec![ColumnDef { name: "a".into(), data_type: DataType::Int(None), options: vec![ColumnOptionDef { name: None, option: ColumnOption::Unique(UniqueConstraint { name: None, index_name: None, index_type_display: KeyOrIndexDisplay::None, index_type: None, columns: vec![], index_options: vec![], characteristics: expected_value, nulls_distinct: NullsDistinctOption::None, }) }] }], "{message}" ) } _ => unreachable!(), } } for deferrable in [None, Some(true), Some(false)] { for initially in [ None, Some(DeferrableInitial::Immediate), Some(DeferrableInitial::Deferred), ] { for enforced in [None, Some(true), Some(false)] { let deferrable_text = deferrable.map(|d| if d { "DEFERRABLE" } else { "NOT DEFERRABLE" }); let initially_text = initially.map(|i| match i { DeferrableInitial::Immediate => "INITIALLY IMMEDIATE", DeferrableInitial::Deferred => "INITIALLY DEFERRED", }); let enforced_text = enforced.map(|e| if e { "ENFORCED" } else { "NOT ENFORCED" }); let syntax = [deferrable_text, initially_text, enforced_text] .into_iter() .flatten() .collect::>() .join(" "); test_combo(&syntax, deferrable, initially, enforced); } } } let res = parse_sql_statements( "CREATE TABLE t (a int NOT NULL UNIQUE DEFERRABLE INITIALLY BADVALUE)", ); assert!(res .unwrap_err() .to_string() .contains("Expected: one of DEFERRED or IMMEDIATE, found: BADVALUE")); let res = parse_sql_statements( "CREATE TABLE t (a int NOT NULL UNIQUE INITIALLY IMMEDIATE DEFERRABLE INITIALLY DEFERRED)", ); res.expect_err("INITIALLY {IMMEDIATE|DEFERRED} setting should only be allowed once"); let res = parse_sql_statements( "CREATE TABLE t (a int NOT NULL UNIQUE DEFERRABLE INITIALLY DEFERRED NOT DEFERRABLE)", ); res.expect_err("[NOT] DEFERRABLE setting should only be allowed once"); let res = parse_sql_statements( "CREATE TABLE t (a int NOT NULL UNIQUE DEFERRABLE INITIALLY DEFERRED ENFORCED NOT ENFORCED)", ); res.expect_err("[NOT] ENFORCED setting should only be allowed once"); } #[test] fn parse_create_table_hive_array() { // Parsing [] type arrays does not work in MsSql since [ is used in is_delimited_identifier_start for (dialects, angle_bracket_syntax) in [ ( vec![Box::new(PostgreSqlDialect {}) as Box], false, ), ( vec![ Box::new(HiveDialect {}) as Box, Box::new(BigQueryDialect {}) as Box, ], true, ), ] { let dialects = TestedDialects::new(dialects); let sql = format!( "CREATE TABLE IF NOT EXISTS something (name INT, val {})", if angle_bracket_syntax { "ARRAY" } else { "INT[]" } ); let expected = Box::new(DataType::Int(None)); let expected = if angle_bracket_syntax { ArrayElemTypeDef::AngleBracket(expected) } else { ArrayElemTypeDef::SquareBracket(expected, None) }; match dialects.one_statement_parses_to(sql.as_str(), sql.as_str()) { Statement::CreateTable(CreateTable { if_not_exists, name, columns, .. }) => { assert!(if_not_exists); assert_eq!(name, ObjectName::from(vec!["something".into()])); assert_eq!( columns, vec![ ColumnDef { name: Ident::new("name"), data_type: DataType::Int(None), options: vec![], }, ColumnDef { name: Ident::new("val"), data_type: DataType::Array(expected), options: vec![], }, ], ) } _ => unreachable!(), } } // SnowflakeDialect using array different let dialects = TestedDialects::new(vec![ Box::new(PostgreSqlDialect {}), Box::new(HiveDialect {}), Box::new(MySqlDialect {}), ]); let sql = "CREATE TABLE IF NOT EXISTS something (name int, val array, found: )".to_string()) ); } #[test] fn parse_create_table_with_multiple_on_delete_in_constraint_fails() { parse_sql_statements( "\ create table X (\ y_id int, \ foreign key (y_id) references Y (id) on delete cascade on update cascade on delete no action\ )", ) .expect_err("should have failed"); } #[test] fn parse_create_table_with_multiple_on_delete_fails() { parse_sql_statements( "\ create table X (\ y_id int references Y (id) \ on delete cascade on update cascade on delete no action\ )", ) .expect_err("should have failed"); } #[test] fn parse_assert() { let sql = "ASSERT (SELECT COUNT(*) FROM my_table) > 0"; let ast = one_statement_parses_to(sql, "ASSERT (SELECT COUNT(*) FROM my_table) > 0"); match ast { Statement::Assert { condition: _condition, message, } => { assert_eq!(message, None); } _ => unreachable!(), } } #[test] #[allow(clippy::collapsible_match)] fn parse_assert_message() { let sql = "ASSERT (SELECT COUNT(*) FROM my_table) > 0 AS 'No rows in my_table'"; let ast = one_statement_parses_to( sql, "ASSERT (SELECT COUNT(*) FROM my_table) > 0 AS 'No rows in my_table'", ); match ast { Statement::Assert { condition: _condition, message: Some(message), } => { match message { Expr::Value(ValueWithSpan { value: Value::SingleQuotedString(s), span: _, }) => assert_eq!(s, "No rows in my_table"), _ => unreachable!(), }; } _ => unreachable!(), } } #[test] fn parse_create_schema() { let sql = "CREATE SCHEMA X"; match verified_stmt(sql) { Statement::CreateSchema { schema_name, .. } => { assert_eq!(schema_name.to_string(), "X".to_owned()) } _ => unreachable!(), } verified_stmt(r#"CREATE SCHEMA a.b.c OPTIONS(key1 = 'value1', key2 = 'value2')"#); verified_stmt(r#"CREATE SCHEMA IF NOT EXISTS a OPTIONS(key1 = 'value1')"#); verified_stmt(r#"CREATE SCHEMA IF NOT EXISTS a OPTIONS()"#); verified_stmt(r#"CREATE SCHEMA IF NOT EXISTS a DEFAULT COLLATE 'und:ci' OPTIONS()"#); verified_stmt(r#"CREATE SCHEMA a.b.c WITH (key1 = 'value1', key2 = 'value2')"#); verified_stmt(r#"CREATE SCHEMA IF NOT EXISTS a WITH (key1 = 'value1')"#); verified_stmt(r#"CREATE SCHEMA IF NOT EXISTS a WITH ()"#); verified_stmt(r#"CREATE SCHEMA a CLONE b"#); } #[test] fn parse_create_schema_with_authorization() { let sql = "CREATE SCHEMA AUTHORIZATION Y"; match verified_stmt(sql) { Statement::CreateSchema { schema_name, .. } => { assert_eq!(schema_name.to_string(), "AUTHORIZATION Y".to_owned()) } _ => unreachable!(), } } #[test] fn parse_create_schema_with_name_and_authorization() { let sql = "CREATE SCHEMA X AUTHORIZATION Y"; match verified_stmt(sql) { Statement::CreateSchema { schema_name, .. } => { assert_eq!(schema_name.to_string(), "X AUTHORIZATION Y".to_owned()) } _ => unreachable!(), } } #[test] fn parse_drop_schema() { let sql = "DROP SCHEMA X"; match verified_stmt(sql) { Statement::Drop { object_type, .. } => assert_eq!(object_type, ObjectType::Schema), _ => unreachable!(), } } #[test] fn parse_create_table_as() { let sql = "CREATE TABLE t AS SELECT * FROM a"; match verified_stmt(sql) { Statement::CreateTable(CreateTable { name, query, .. }) => { assert_eq!(name.to_string(), "t".to_string()); assert_eq!(query, Some(Box::new(verified_query("SELECT * FROM a")))); } _ => unreachable!(), } // BigQuery allows specifying table schema in CTAS // ANSI SQL and PostgreSQL let you only specify the list of columns // (without data types) in a CTAS, but we have yet to support that. let dialects = all_dialects_where(|d| d.supports_create_table_multi_schema_info_sources()); let sql = "CREATE TABLE t (a INT, b INT) AS SELECT 1 AS b, 2 AS a"; match dialects.verified_stmt(sql) { Statement::CreateTable(CreateTable { columns, query, .. }) => { assert_eq!(columns.len(), 2); assert_eq!(columns[0].to_string(), "a INT".to_string()); assert_eq!(columns[1].to_string(), "b INT".to_string()); assert_eq!( query, Some(Box::new(verified_query("SELECT 1 AS b, 2 AS a"))) ); } _ => unreachable!(), } } #[test] fn parse_create_table_as_table() { let sql1 = "CREATE TABLE new_table AS TABLE old_table"; let expected_query1 = Box::new(Query { with: None, body: Box::new(SetExpr::Table(Box::new(Table { table_name: Some("old_table".to_string()), schema_name: None, }))), order_by: None, limit_clause: None, fetch: None, locks: vec![], for_clause: None, settings: None, format_clause: None, pipe_operators: vec![], }); match verified_stmt(sql1) { Statement::CreateTable(CreateTable { query, name, .. }) => { assert_eq!(name, ObjectName::from(vec![Ident::new("new_table")])); assert_eq!(query.unwrap(), expected_query1); } _ => unreachable!(), } let sql2 = "CREATE TABLE new_table AS TABLE schema_name.old_table"; let expected_query2 = Box::new(Query { with: None, body: Box::new(SetExpr::Table(Box::new(Table { table_name: Some("old_table".to_string()), schema_name: Some("schema_name".to_string()), }))), order_by: None, limit_clause: None, fetch: None, locks: vec![], for_clause: None, settings: None, format_clause: None, pipe_operators: vec![], }); match verified_stmt(sql2) { Statement::CreateTable(CreateTable { query, name, .. }) => { assert_eq!(name, ObjectName::from(vec![Ident::new("new_table")])); assert_eq!(query.unwrap(), expected_query2); } _ => unreachable!(), } } #[test] fn parse_create_table_on_cluster() { let generic = TestedDialects::new(vec![Box::new(GenericDialect {})]); // Using single-quote literal to define current cluster let sql = "CREATE TABLE t ON CLUSTER '{cluster}' (a INT, b INT)"; match generic.verified_stmt(sql) { Statement::CreateTable(CreateTable { on_cluster, .. }) => { assert_eq!(on_cluster.unwrap().to_string(), "'{cluster}'".to_string()); } _ => unreachable!(), } // Using explicitly declared cluster name let sql = "CREATE TABLE t ON CLUSTER my_cluster (a INT, b INT)"; match generic.verified_stmt(sql) { Statement::CreateTable(CreateTable { on_cluster, .. }) => { assert_eq!(on_cluster.unwrap().to_string(), "my_cluster".to_string()); } _ => unreachable!(), } } #[test] fn parse_create_or_replace_table() { let sql = "CREATE OR REPLACE TABLE t (a INT)"; match verified_stmt(sql) { Statement::CreateTable(CreateTable { name, or_replace, .. }) => { assert_eq!(name.to_string(), "t".to_string()); assert!(or_replace); } _ => unreachable!(), } } #[test] fn parse_create_table_with_on_delete_on_update_2in_any_order() -> Result<(), ParserError> { let sql = |options: &str| -> String { format!("create table X (y_id int references Y (id) {options})") }; parse_sql_statements(&sql("on update cascade on delete no action"))?; parse_sql_statements(&sql("on delete cascade on update cascade"))?; parse_sql_statements(&sql("on update no action"))?; parse_sql_statements(&sql("on delete restrict"))?; Ok(()) } #[test] fn parse_create_table_with_options() { let generic = TestedDialects::new(vec![Box::new(GenericDialect {})]); let sql = "CREATE TABLE t (c INT) WITH (foo = 'bar', a = 123)"; match generic.verified_stmt(sql) { Statement::CreateTable(CreateTable { table_options, .. }) => { let with_options = match table_options { CreateTableOptions::With(options) => options, _ => unreachable!(), }; assert_eq!( vec![ SqlOption::KeyValue { key: "foo".into(), value: Expr::Value( (Value::SingleQuotedString("bar".into())).with_empty_span() ), }, SqlOption::KeyValue { key: "a".into(), value: Expr::value(number("123")), }, ], with_options ); } _ => unreachable!(), } } #[test] fn parse_create_table_clone() { let sql = "CREATE OR REPLACE TABLE a CLONE a_tmp"; match verified_stmt(sql) { Statement::CreateTable(CreateTable { name, clone, .. }) => { assert_eq!(ObjectName::from(vec![Ident::new("a")]), name); assert_eq!(Some(ObjectName::from(vec![(Ident::new("a_tmp"))])), clone) } _ => unreachable!(), } } #[test] fn parse_create_table_trailing_comma() { let dialect = TestedDialects::new(vec![Box::new(DuckDbDialect {})]); let sql = "CREATE TABLE foo (bar int,);"; dialect.one_statement_parses_to(sql, "CREATE TABLE foo (bar INT)"); } #[test] fn parse_create_external_table() { let sql = "CREATE EXTERNAL TABLE uk_cities (\ name VARCHAR(100) NOT NULL,\ lat DOUBLE NULL,\ lng DOUBLE)\ STORED AS TEXTFILE LOCATION '/tmp/example.csv'"; let ast = one_statement_parses_to( sql, "CREATE EXTERNAL TABLE uk_cities (\ name VARCHAR(100) NOT NULL, \ lat DOUBLE NULL, \ lng DOUBLE) \ STORED AS TEXTFILE LOCATION '/tmp/example.csv'", ); match ast { Statement::CreateTable(CreateTable { name, columns, constraints, table_options, if_not_exists, external, file_format, location, .. }) => { assert_eq!("uk_cities", name.to_string()); assert_eq!( columns, vec![ ColumnDef { name: "name".into(), data_type: DataType::Varchar(Some(CharacterLength::IntegerLength { length: 100, unit: None, })), options: vec![ColumnOptionDef { name: None, option: ColumnOption::NotNull, }], }, ColumnDef { name: "lat".into(), data_type: DataType::Double(ExactNumberInfo::None), options: vec![ColumnOptionDef { name: None, option: ColumnOption::Null, }], }, ColumnDef { name: "lng".into(), data_type: DataType::Double(ExactNumberInfo::None), options: vec![], }, ] ); assert!(constraints.is_empty()); assert!(external); assert_eq!(FileFormat::TEXTFILE, file_format.unwrap()); assert_eq!("/tmp/example.csv", location.unwrap()); assert_eq!(table_options, CreateTableOptions::None); assert!(!if_not_exists); } _ => unreachable!(), } } #[test] fn parse_create_or_replace_external_table() { // Supported by at least Snowflake // https://docs.snowflake.com/en/sql-reference/sql/create-external-table.html let sql = "CREATE OR REPLACE EXTERNAL TABLE uk_cities (\ name VARCHAR(100) NOT NULL)\ STORED AS TEXTFILE LOCATION '/tmp/example.csv'"; let ast = one_statement_parses_to( sql, "CREATE OR REPLACE EXTERNAL TABLE uk_cities (\ name VARCHAR(100) NOT NULL) \ STORED AS TEXTFILE LOCATION '/tmp/example.csv'", ); match ast { Statement::CreateTable(CreateTable { name, columns, constraints, table_options, if_not_exists, external, file_format, location, or_replace, .. }) => { assert_eq!("uk_cities", name.to_string()); assert_eq!( columns, vec![ColumnDef { name: "name".into(), data_type: DataType::Varchar(Some(CharacterLength::IntegerLength { length: 100, unit: None, })), options: vec![ColumnOptionDef { name: None, option: ColumnOption::NotNull, }], },] ); assert!(constraints.is_empty()); assert!(external); assert_eq!(FileFormat::TEXTFILE, file_format.unwrap()); assert_eq!("/tmp/example.csv", location.unwrap()); assert_eq!(table_options, CreateTableOptions::None); assert!(!if_not_exists); assert!(or_replace); } _ => unreachable!(), } } #[test] fn parse_create_external_table_lowercase() { let sql = "create external table uk_cities (\ name varchar(100) not null,\ lat double null,\ lng double)\ stored as parquet location '/tmp/example.csv'"; let ast = one_statement_parses_to( sql, "CREATE EXTERNAL TABLE uk_cities (\ name VARCHAR(100) NOT NULL, \ lat DOUBLE NULL, \ lng DOUBLE) \ STORED AS PARQUET LOCATION '/tmp/example.csv'", ); assert_matches!(ast, Statement::CreateTable(CreateTable { .. })); } #[test] fn parse_create_table_hive_formats_none_when_no_options() { let sql = "CREATE TABLE simple_table (id INT, name VARCHAR(100))"; match verified_stmt(sql) { Statement::CreateTable(CreateTable { hive_formats, .. }) => { assert_eq!(hive_formats, None); } _ => unreachable!(), } } #[test] fn parse_alter_table() { let add_column = "ALTER TABLE tab ADD COLUMN foo TEXT;"; match alter_table_op(one_statement_parses_to( add_column, "ALTER TABLE tab ADD COLUMN foo TEXT", )) { AlterTableOperation::AddColumn { column_keyword, if_not_exists, column_def, column_position, } => { assert!(column_keyword); assert!(!if_not_exists); assert_eq!("foo", column_def.name.to_string()); assert_eq!("TEXT", column_def.data_type.to_string()); assert_eq!(None, column_position); } _ => unreachable!(), }; let rename_table = "ALTER TABLE tab RENAME TO new_tab"; match alter_table_op(verified_stmt(rename_table)) { AlterTableOperation::RenameTable { table_name } => { assert_eq!( RenameTableNameKind::To(ObjectName::from(vec![Ident::new("new_tab")])), table_name ); } _ => unreachable!(), }; let rename_table_as = "ALTER TABLE tab RENAME AS new_tab"; match alter_table_op(verified_stmt(rename_table_as)) { AlterTableOperation::RenameTable { table_name } => { assert_eq!( RenameTableNameKind::As(ObjectName::from(vec![Ident::new("new_tab")])), table_name ); } _ => unreachable!(), }; let rename_column = "ALTER TABLE tab RENAME COLUMN foo TO new_foo"; match alter_table_op(verified_stmt(rename_column)) { AlterTableOperation::RenameColumn { old_column_name, new_column_name, } => { assert_eq!(old_column_name.to_string(), "foo"); assert_eq!(new_column_name.to_string(), "new_foo"); } _ => unreachable!(), } let set_table_properties = "ALTER TABLE tab SET TBLPROPERTIES('classification' = 'parquet')"; match alter_table_op(verified_stmt(set_table_properties)) { AlterTableOperation::SetTblProperties { table_properties } => { assert_eq!( table_properties, [SqlOption::KeyValue { key: Ident { value: "classification".to_string(), quote_style: Some('\''), span: Span::empty(), }, value: Expr::Value( (Value::SingleQuotedString("parquet".to_string())).with_empty_span() ), }], ); } _ => unreachable!(), } let set_storage_parameters = "ALTER TABLE tab SET (autovacuum_vacuum_scale_factor = 0.01, autovacuum_vacuum_threshold = 500)"; match alter_table_op(verified_stmt(set_storage_parameters)) { AlterTableOperation::SetOptionsParens { options } => { assert_eq!( options, [ SqlOption::KeyValue { key: Ident { value: "autovacuum_vacuum_scale_factor".to_string(), quote_style: None, span: Span::empty(), }, value: Expr::Value(test_utils::number("0.01").with_empty_span()), }, SqlOption::KeyValue { key: Ident { value: "autovacuum_vacuum_threshold".to_string(), quote_style: None, span: Span::empty(), }, value: Expr::Value(test_utils::number("500").with_empty_span()), } ], ); } _ => unreachable!(), } } #[test] fn parse_rename_table() { match verified_stmt("RENAME TABLE test.test1 TO test_db.test2") { Statement::RenameTable(rename_tables) => { assert_eq!( vec![RenameTable { old_name: ObjectName::from(vec![ Ident::new("test".to_string()), Ident::new("test1".to_string()), ]), new_name: ObjectName::from(vec![ Ident::new("test_db".to_string()), Ident::new("test2".to_string()), ]), }], rename_tables ); } _ => unreachable!(), }; match verified_stmt( "RENAME TABLE old_table1 TO new_table1, old_table2 TO new_table2, old_table3 TO new_table3", ) { Statement::RenameTable(rename_tables) => { assert_eq!( vec![ RenameTable { old_name: ObjectName::from(vec![Ident::new("old_table1".to_string())]), new_name: ObjectName::from(vec![Ident::new("new_table1".to_string())]), }, RenameTable { old_name: ObjectName::from(vec![Ident::new("old_table2".to_string())]), new_name: ObjectName::from(vec![Ident::new("new_table2".to_string())]), }, RenameTable { old_name: ObjectName::from(vec![Ident::new("old_table3".to_string())]), new_name: ObjectName::from(vec![Ident::new("new_table3".to_string())]), } ], rename_tables ); } _ => unreachable!(), }; assert_eq!( parse_sql_statements("RENAME TABLE old_table TO new_table a").unwrap_err(), ParserError::ParserError("Expected: end of statement, found: a".to_string()) ); assert_eq!( parse_sql_statements("RENAME TABLE1 old_table TO new_table a").unwrap_err(), ParserError::ParserError( "Expected: KEYWORD `TABLE` after RENAME, found: TABLE1".to_string() ) ); } #[test] fn test_alter_table_with_on_cluster() { match all_dialects() .verified_stmt("ALTER TABLE t ON CLUSTER 'cluster' ADD CONSTRAINT bar PRIMARY KEY (baz)") { Statement::AlterTable(AlterTable { name, on_cluster, .. }) => { assert_eq!(name.to_string(), "t"); assert_eq!(on_cluster, Some(Ident::with_quote('\'', "cluster"))); } _ => unreachable!(), } match all_dialects() .verified_stmt("ALTER TABLE t ON CLUSTER cluster_name ADD CONSTRAINT bar PRIMARY KEY (baz)") { Statement::AlterTable(AlterTable { name, on_cluster, .. }) => { assert_eq!(name.to_string(), "t"); assert_eq!(on_cluster, Some(Ident::new("cluster_name"))); } _ => unreachable!(), } let res = all_dialects() .parse_sql_statements("ALTER TABLE t ON CLUSTER 123 ADD CONSTRAINT bar PRIMARY KEY (baz)"); assert_eq!( res.unwrap_err(), ParserError::ParserError("Expected: identifier, found: 123".to_string()) ) } #[test] fn parse_alter_index() { let rename_index = "ALTER INDEX idx RENAME TO new_idx"; match verified_stmt(rename_index) { Statement::AlterIndex { name, operation: AlterIndexOperation::RenameIndex { index_name }, } => { assert_eq!("idx", name.to_string()); assert_eq!("new_idx", index_name.to_string()) } _ => unreachable!(), }; } #[test] fn parse_alter_view() { let sql = "ALTER VIEW myschema.myview AS SELECT foo FROM bar"; match verified_stmt(sql) { Statement::AlterView { name, columns, query, with_options, } => { assert_eq!("myschema.myview", name.to_string()); assert_eq!(Vec::::new(), columns); assert_eq!("SELECT foo FROM bar", query.to_string()); assert_eq!(with_options, vec![]); } _ => unreachable!(), } } #[test] fn parse_alter_view_with_options() { let sql = "ALTER VIEW v WITH (foo = 'bar', a = 123) AS SELECT 1"; match verified_stmt(sql) { Statement::AlterView { with_options, .. } => { assert_eq!( vec![ SqlOption::KeyValue { key: "foo".into(), value: Expr::Value( (Value::SingleQuotedString("bar".into())).with_empty_span() ), }, SqlOption::KeyValue { key: "a".into(), value: Expr::value(number("123")), }, ], with_options ); } _ => unreachable!(), } } #[test] fn parse_alter_view_with_columns() { let sql = "ALTER VIEW v (has, cols) AS SELECT 1, 2"; match verified_stmt(sql) { Statement::AlterView { name, columns, query, with_options, } => { assert_eq!("v", name.to_string()); assert_eq!(columns, vec![Ident::new("has"), Ident::new("cols")]); assert_eq!("SELECT 1, 2", query.to_string()); assert_eq!(with_options, vec![]); } _ => unreachable!(), } } #[test] fn parse_alter_table_add_column() { match alter_table_op(verified_stmt("ALTER TABLE tab ADD foo TEXT")) { AlterTableOperation::AddColumn { column_keyword, .. } => { assert!(!column_keyword); } _ => unreachable!(), }; match alter_table_op(verified_stmt("ALTER TABLE tab ADD COLUMN foo TEXT")) { AlterTableOperation::AddColumn { column_keyword, .. } => { assert!(column_keyword); } _ => unreachable!(), }; } #[test] fn parse_alter_table_add_column_if_not_exists() { let dialects = TestedDialects::new(vec![ Box::new(PostgreSqlDialect {}), Box::new(BigQueryDialect {}), Box::new(GenericDialect {}), Box::new(DuckDbDialect {}), ]); match alter_table_op(dialects.verified_stmt("ALTER TABLE tab ADD IF NOT EXISTS foo TEXT")) { AlterTableOperation::AddColumn { if_not_exists, .. } => { assert!(if_not_exists); } _ => unreachable!(), }; match alter_table_op( dialects.verified_stmt("ALTER TABLE tab ADD COLUMN IF NOT EXISTS foo TEXT"), ) { AlterTableOperation::AddColumn { column_keyword, if_not_exists, .. } => { assert!(column_keyword); assert!(if_not_exists); } _ => unreachable!(), }; } #[test] fn parse_alter_table_constraints() { check_one("CONSTRAINT address_pkey PRIMARY KEY (address_id)"); check_one("CONSTRAINT uk_task UNIQUE (report_date, task_id)"); check_one( "CONSTRAINT customer_address_id_fkey FOREIGN KEY (address_id) \ REFERENCES public.address(address_id)", ); check_one("CONSTRAINT ck CHECK (rtrim(ltrim(REF_CODE)) <> '')"); check_one("PRIMARY KEY (foo, bar)"); check_one("UNIQUE (id)"); check_one("FOREIGN KEY (foo, bar) REFERENCES AnotherTable(foo, bar)"); check_one("CHECK (end_date > start_date OR end_date IS NULL)"); check_one("CONSTRAINT fk FOREIGN KEY (lng) REFERENCES othertable4"); fn check_one(constraint_text: &str) { match alter_table_op(verified_stmt(&format!( "ALTER TABLE tab ADD {constraint_text}" ))) { AlterTableOperation::AddConstraint { constraint, .. } => { assert_eq!(constraint_text, constraint.to_string()); } _ => unreachable!(), } verified_stmt(&format!("CREATE TABLE foo (id INT, {constraint_text})")); } } #[test] fn parse_alter_table_drop_column() { check_one("DROP COLUMN IF EXISTS is_active"); check_one("DROP COLUMN IF EXISTS is_active CASCADE"); check_one("DROP COLUMN IF EXISTS is_active RESTRICT"); one_statement_parses_to( "ALTER TABLE tab DROP COLUMN IF EXISTS is_active CASCADE", "ALTER TABLE tab DROP COLUMN IF EXISTS is_active CASCADE", ); one_statement_parses_to( "ALTER TABLE tab DROP is_active CASCADE", "ALTER TABLE tab DROP is_active CASCADE", ); let dialects = all_dialects_where(|d| d.supports_comma_separated_drop_column_list()); dialects.verified_stmt("ALTER TABLE tbl DROP COLUMN c1, c2, c3"); fn check_one(constraint_text: &str) { match alter_table_op(verified_stmt(&format!("ALTER TABLE tab {constraint_text}"))) { AlterTableOperation::DropColumn { has_column_keyword: true, column_names, if_exists, drop_behavior, } => { assert_eq!("is_active", column_names.first().unwrap().to_string()); assert!(if_exists); match drop_behavior { None => assert!(constraint_text.ends_with(" is_active")), Some(DropBehavior::Restrict) => assert!(constraint_text.ends_with(" RESTRICT")), Some(DropBehavior::Cascade) => assert!(constraint_text.ends_with(" CASCADE")), } } _ => unreachable!(), } } } #[test] fn parse_alter_table_alter_column() { let alter_stmt = "ALTER TABLE tab"; match alter_table_op(verified_stmt(&format!( "{alter_stmt} ALTER COLUMN is_active SET NOT NULL" ))) { AlterTableOperation::AlterColumn { column_name, op } => { assert_eq!("is_active", column_name.to_string()); assert_eq!(op, AlterColumnOperation::SetNotNull {}); } _ => unreachable!(), } one_statement_parses_to( "ALTER TABLE tab ALTER is_active DROP NOT NULL", "ALTER TABLE tab ALTER COLUMN is_active DROP NOT NULL", ); match alter_table_op(verified_stmt(&format!( "{alter_stmt} ALTER COLUMN is_active SET DEFAULT 0" ))) { AlterTableOperation::AlterColumn { column_name, op } => { assert_eq!("is_active", column_name.to_string()); assert_eq!( op, AlterColumnOperation::SetDefault { value: Expr::Value((test_utils::number("0")).with_empty_span()) } ); } _ => unreachable!(), } match alter_table_op(verified_stmt(&format!( "{alter_stmt} ALTER COLUMN is_active DROP DEFAULT" ))) { AlterTableOperation::AlterColumn { column_name, op } => { assert_eq!("is_active", column_name.to_string()); assert_eq!(op, AlterColumnOperation::DropDefault {}); } _ => unreachable!(), } } #[test] fn parse_alter_table_alter_column_type() { let alter_stmt = "ALTER TABLE tab"; match alter_table_op(verified_stmt( "ALTER TABLE tab ALTER COLUMN is_active SET DATA TYPE TEXT", )) { AlterTableOperation::AlterColumn { column_name, op } => { assert_eq!("is_active", column_name.to_string()); assert_eq!( op, AlterColumnOperation::SetDataType { data_type: DataType::Text, using: None, had_set: true, } ); } _ => unreachable!(), } verified_stmt(&format!("{alter_stmt} ALTER COLUMN is_active TYPE TEXT")); let dialects = all_dialects_where(|d| d.supports_alter_column_type_using()); dialects.verified_stmt(&format!( "{alter_stmt} ALTER COLUMN is_active SET DATA TYPE TEXT USING 'text'" )); let dialects = all_dialects_except(|d| d.supports_alter_column_type_using()); let res = dialects.parse_sql_statements(&format!( "{alter_stmt} ALTER COLUMN is_active SET DATA TYPE TEXT USING 'text'" )); assert_eq!( ParserError::ParserError("Expected: end of statement, found: USING".to_string()), res.unwrap_err() ); } #[test] fn parse_alter_table_drop_constraint() { check_one("DROP CONSTRAINT IF EXISTS constraint_name"); check_one("DROP CONSTRAINT IF EXISTS constraint_name RESTRICT"); check_one("DROP CONSTRAINT IF EXISTS constraint_name CASCADE"); fn check_one(constraint_text: &str) { match alter_table_op(verified_stmt(&format!("ALTER TABLE tab {constraint_text}"))) { AlterTableOperation::DropConstraint { name: constr_name, if_exists, drop_behavior, } => { assert_eq!("constraint_name", constr_name.to_string()); assert!(if_exists); match drop_behavior { None => assert!(constraint_text.ends_with(" constraint_name")), Some(DropBehavior::Restrict) => assert!(constraint_text.ends_with(" RESTRICT")), Some(DropBehavior::Cascade) => assert!(constraint_text.ends_with(" CASCADE")), } } _ => unreachable!(), } } let res = parse_sql_statements("ALTER TABLE tab DROP CONSTRAINT is_active TEXT"); assert_eq!( ParserError::ParserError("Expected: end of statement, found: TEXT".to_string()), res.unwrap_err() ); } #[test] fn parse_bad_constraint() { let res = parse_sql_statements("ALTER TABLE tab ADD"); assert_eq!( ParserError::ParserError("Expected: identifier, found: EOF".to_string()), res.unwrap_err() ); let res = parse_sql_statements("CREATE TABLE tab (foo int,"); assert_eq!( ParserError::ParserError( "Expected: column name or constraint definition, found: EOF".to_string() ), res.unwrap_err() ); } #[test] fn parse_scalar_function_in_projection() { let names = vec!["sqrt", "foo"]; for function_name in names { // like SELECT sqrt(id) FROM foo let sql = format!("SELECT {function_name}(id) FROM foo"); let select = verified_only_select(&sql); assert_eq!( &call(function_name, [Expr::Identifier(Ident::new("id"))]), expr_from_projection(only(&select.projection)) ); } } fn run_explain_analyze( dialect: TestedDialects, query: &str, expected_verbose: bool, expected_analyze: bool, expected_format: Option, expected_options: Option>, ) { match dialect.verified_stmt(query) { Statement::Explain { describe_alias: _, analyze, verbose, query_plan, estimate, statement, format, options, } => { assert_eq!(verbose, expected_verbose); assert_eq!(analyze, expected_analyze); assert_eq!(format, expected_format); assert_eq!(options, expected_options); assert!(!query_plan); assert!(!estimate); assert_eq!("SELECT sqrt(id) FROM foo", statement.to_string()); } _ => panic!("Unexpected Statement, must be Explain"), } } #[test] fn parse_explain_table() { let validate_explain = |query: &str, expected_describe_alias: DescribeAlias, expected_table_keyword| { match verified_stmt(query) { Statement::ExplainTable { describe_alias, hive_format, has_table_keyword, table_name, } => { assert_eq!(describe_alias, expected_describe_alias); assert_eq!(hive_format, None); assert_eq!(has_table_keyword, expected_table_keyword); assert_eq!("test_identifier", table_name.to_string()); } _ => panic!("Unexpected Statement, must be ExplainTable"), } }; validate_explain("EXPLAIN test_identifier", DescribeAlias::Explain, false); validate_explain("DESCRIBE test_identifier", DescribeAlias::Describe, false); validate_explain("DESC test_identifier", DescribeAlias::Desc, false); } #[test] fn explain_describe() { verified_stmt("DESCRIBE test.table"); } #[test] fn explain_desc() { verified_stmt("DESC test.table"); } #[test] fn parse_explain_analyze_with_simple_select() { // Describe is an alias for EXPLAIN run_explain_analyze( all_dialects(), "DESCRIBE SELECT sqrt(id) FROM foo", false, false, None, None, ); run_explain_analyze( all_dialects(), "EXPLAIN SELECT sqrt(id) FROM foo", false, false, None, None, ); run_explain_analyze( all_dialects(), "EXPLAIN VERBOSE SELECT sqrt(id) FROM foo", true, false, None, None, ); run_explain_analyze( all_dialects(), "EXPLAIN ANALYZE SELECT sqrt(id) FROM foo", false, true, None, None, ); run_explain_analyze( all_dialects(), "EXPLAIN ANALYZE VERBOSE SELECT sqrt(id) FROM foo", true, true, None, None, ); run_explain_analyze( all_dialects(), "EXPLAIN ANALYZE FORMAT GRAPHVIZ SELECT sqrt(id) FROM foo", false, true, Some(AnalyzeFormatKind::Keyword(AnalyzeFormat::GRAPHVIZ)), None, ); run_explain_analyze( all_dialects(), "EXPLAIN ANALYZE VERBOSE FORMAT JSON SELECT sqrt(id) FROM foo", true, true, Some(AnalyzeFormatKind::Keyword(AnalyzeFormat::JSON)), None, ); run_explain_analyze( all_dialects(), "EXPLAIN ANALYZE VERBOSE FORMAT=JSON SELECT sqrt(id) FROM foo", true, true, Some(AnalyzeFormatKind::Assignment(AnalyzeFormat::JSON)), None, ); run_explain_analyze( all_dialects(), "EXPLAIN VERBOSE FORMAT TEXT SELECT sqrt(id) FROM foo", true, false, Some(AnalyzeFormatKind::Keyword(AnalyzeFormat::TEXT)), None, ); run_explain_analyze( all_dialects(), "EXPLAIN FORMAT=TEXT SELECT sqrt(id) FROM foo", false, false, Some(AnalyzeFormatKind::Assignment(AnalyzeFormat::TEXT)), None, ); run_explain_analyze( all_dialects(), "EXPLAIN FORMAT=GRAPHVIZ SELECT sqrt(id) FROM foo", false, false, Some(AnalyzeFormatKind::Assignment(AnalyzeFormat::GRAPHVIZ)), None, ); run_explain_analyze( all_dialects(), "EXPLAIN FORMAT=JSON SELECT sqrt(id) FROM foo", false, false, Some(AnalyzeFormatKind::Assignment(AnalyzeFormat::JSON)), None, ); run_explain_analyze( all_dialects(), "EXPLAIN FORMAT=TREE SELECT sqrt(id) FROM foo", false, false, Some(AnalyzeFormatKind::Assignment(AnalyzeFormat::TREE)), None, ); } #[test] fn parse_explain_query_plan() { match all_dialects().verified_stmt("EXPLAIN QUERY PLAN SELECT sqrt(id) FROM foo") { Statement::Explain { query_plan, analyze, verbose, statement, .. } => { assert!(query_plan); assert!(!analyze); assert!(!verbose); assert_eq!("SELECT sqrt(id) FROM foo", statement.to_string()); } _ => unreachable!(), } // omit QUERY PLAN should be good all_dialects().verified_stmt("EXPLAIN SELECT sqrt(id) FROM foo"); // missing PLAN keyword should return error assert_eq!( ParserError::ParserError("Expected: end of statement, found: SELECT".to_string()), all_dialects() .parse_sql_statements("EXPLAIN QUERY SELECT sqrt(id) FROM foo") .unwrap_err() ); } #[test] fn parse_explain_estimate() { let statement = all_dialects().verified_stmt("EXPLAIN ESTIMATE SELECT sqrt(id) FROM foo"); match &statement { Statement::Explain { query_plan, estimate, analyze, verbose, statement, .. } => { assert!(estimate); assert!(!query_plan); assert!(!analyze); assert!(!verbose); assert_eq!("SELECT sqrt(id) FROM foo", statement.to_string()); } _ => unreachable!(), } assert_eq!( "EXPLAIN ESTIMATE SELECT sqrt(id) FROM foo", statement.to_string() ); } #[test] fn parse_named_argument_function() { let dialects = all_dialects_where(|d| { d.supports_named_fn_args_with_rarrow_operator() && !d.supports_named_fn_args_with_expr_name() }); let sql = "SELECT FUN(a => '1', b => '2') FROM foo"; let select = dialects.verified_only_select(sql); assert_eq!( &Expr::Function(Function { name: ObjectName::from(vec![Ident::new("FUN")]), uses_odbc_syntax: false, 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() )), operator: FunctionArgOperator::RightArrow }, FunctionArg::Named { name: Ident::new("b"), arg: FunctionArgExpr::Expr(Expr::Value( (Value::SingleQuotedString("2".to_owned())).with_empty_span() )), operator: FunctionArgOperator::RightArrow }, ], clauses: vec![], }), null_treatment: None, filter: None, over: None, within_group: vec![] }), expr_from_projection(only(&select.projection)) ); } #[test] fn parse_named_argument_function_with_eq_operator() { let sql = "SELECT FUN(a = '1', b = '2') FROM foo"; let select = all_dialects_where(|d| d.supports_named_fn_args_with_eq_operator()) .verified_only_select(sql); assert_eq!( &Expr::Function(Function { name: ObjectName::from(vec![Ident::new("FUN")]), uses_odbc_syntax: false, 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() )), operator: FunctionArgOperator::Equals }, FunctionArg::Named { name: Ident::new("b"), arg: FunctionArgExpr::Expr(Expr::Value( (Value::SingleQuotedString("2".to_owned())).with_empty_span() )), operator: FunctionArgOperator::Equals }, ], clauses: vec![], }), null_treatment: None, filter: None, over: None, within_group: vec![], }), expr_from_projection(only(&select.projection)) ); // Ensure that bar = 42 in a function argument parses as an equality binop // rather than a named function argument. assert_eq!( all_dialects_except(|d| d.supports_named_fn_args_with_eq_operator()) .verified_expr("foo(bar = 42)"), call( "foo", [Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("bar"))), op: BinaryOperator::Eq, right: Box::new(Expr::value(number("42"))), }] ), ); // TODO: should this parse for all dialects? all_dialects_except(|d| d.supports_named_fn_args_with_eq_operator()) .verified_expr("iff(1 = 1, 1, 0)"); } #[test] fn parse_window_functions() { let sql = "SELECT row_number() OVER (ORDER BY dt DESC), \ sum(foo) OVER (PARTITION BY a, b ORDER BY c, d \ ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), \ avg(bar) OVER (ORDER BY a \ RANGE BETWEEN 1 PRECEDING AND 1 FOLLOWING), \ sum(bar) OVER (ORDER BY a \ RANGE BETWEEN INTERVAL '1' DAY PRECEDING AND INTERVAL '1 MONTH' FOLLOWING), \ COUNT(*) OVER (ORDER BY a \ RANGE BETWEEN INTERVAL '1 DAY' PRECEDING AND INTERVAL '1 DAY' FOLLOWING), \ max(baz) OVER (ORDER BY a \ ROWS UNBOUNDED PRECEDING), \ sum(qux) OVER (ORDER BY a \ GROUPS BETWEEN 1 PRECEDING AND 1 FOLLOWING) \ FROM foo"; let dialects = all_dialects_except(|d| d.require_interval_qualifier()); let select = dialects.verified_only_select(sql); const EXPECTED_PROJ_QTY: usize = 7; assert_eq!(EXPECTED_PROJ_QTY, select.projection.len()); assert_eq!( &Expr::Function(Function { name: ObjectName::from(vec![Ident::new("row_number")]), uses_odbc_syntax: false, parameters: FunctionArguments::None, args: FunctionArguments::List(FunctionArgumentList { duplicate_treatment: None, args: vec![], clauses: vec![], }), null_treatment: None, filter: None, over: Some(WindowType::WindowSpec(WindowSpec { window_name: None, partition_by: vec![], order_by: vec![OrderByExpr { expr: Expr::Identifier(Ident::new("dt")), options: OrderByOptions { asc: Some(false), nulls_first: None, }, with_fill: None, }], window_frame: None, })), within_group: vec![], }), expr_from_projection(&select.projection[0]) ); for i in 0..EXPECTED_PROJ_QTY { assert!(matches!( expr_from_projection(&select.projection[i]), Expr::Function(Function { over: Some(WindowType::WindowSpec(WindowSpec { window_name: None, .. })), .. }) )); } } #[test] fn parse_named_window_functions() { let supported_dialects = TestedDialects::new(vec![ Box::new(GenericDialect {}), Box::new(PostgreSqlDialect {}), Box::new(MySqlDialect {}), Box::new(BigQueryDialect {}), ]); let sql = "SELECT row_number() OVER (w ORDER BY dt DESC), \ sum(foo) OVER (win PARTITION BY a, b ORDER BY c, d \ ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) \ FROM foo \ WINDOW w AS (PARTITION BY x), win AS (ORDER BY y)"; supported_dialects.verified_stmt(sql); let select = all_dialects_except(|d| d.is_table_alias(&Keyword::WINDOW, &mut Parser::new(d))) .verified_only_select(sql); const EXPECTED_PROJ_QTY: usize = 2; assert_eq!(EXPECTED_PROJ_QTY, select.projection.len()); const EXPECTED_WIN_NAMES: [&str; 2] = ["w", "win"]; for (i, win_name) in EXPECTED_WIN_NAMES.iter().enumerate() { assert!(matches!( expr_from_projection(&select.projection[i]), Expr::Function(Function { over: Some(WindowType::WindowSpec(WindowSpec { window_name: Some(Ident { value, .. }), .. })), .. }) if value == win_name )); } let sql = "SELECT \ FIRST_VALUE(x) OVER (w ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS first, \ FIRST_VALUE(x) OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS last, \ SUM(y) OVER (win PARTITION BY x) AS last \ FROM EMPLOYEE \ WINDOW w AS (PARTITION BY x), win AS (w ORDER BY y)"; supported_dialects.verified_stmt(sql); } #[test] fn parse_window_clause() { let dialects = all_dialects_except(|d| d.is_table_alias(&Keyword::WINDOW, &mut Parser::new(d))); let sql = "SELECT * \ FROM mytable \ WINDOW \ window1 AS (ORDER BY 1 ASC, 2 DESC, 3 NULLS FIRST), \ window2 AS (window1), \ window3 AS (PARTITION BY a, b, c), \ window4 AS (ROWS UNBOUNDED PRECEDING), \ window5 AS (window1 PARTITION BY a), \ window6 AS (window1 ORDER BY a), \ window7 AS (window1 ROWS UNBOUNDED PRECEDING), \ window8 AS (window1 PARTITION BY a ORDER BY b ROWS UNBOUNDED PRECEDING) \ ORDER BY C3"; dialects.verified_only_select(sql); let sql = "SELECT * from mytable WINDOW window1 AS window2"; let dialects = all_dialects_except(|d| { d.is::() || d.is::() || d.is_table_alias(&Keyword::WINDOW, &mut Parser::new(d)) }); let res = dialects.parse_sql_statements(sql); assert_eq!( ParserError::ParserError("Expected: (, found: window2".to_string()), res.unwrap_err() ); } #[test] fn test_parse_named_window() { let dialects = all_dialects_except(|d| d.is_table_alias(&Keyword::WINDOW, &mut Parser::new(d))); let sql = "SELECT \ MIN(c12) OVER window1 AS min1, \ MAX(c12) OVER window2 AS max1 \ FROM aggregate_test_100 \ WINDOW window1 AS (ORDER BY C12), \ window2 AS (PARTITION BY C11) \ ORDER BY C3"; let actual_select_only = dialects.verified_only_select(sql); let expected = Select { select_token: AttachedToken::empty(), optimizer_hints: vec![], distinct: None, select_modifiers: None, top: None, top_before_distinct: false, projection: vec![ SelectItem::ExprWithAlias { expr: Expr::Function(Function { name: ObjectName::from(vec![Ident { value: "MIN".to_string(), quote_style: None, span: Span::empty(), }]), uses_odbc_syntax: false, parameters: FunctionArguments::None, args: FunctionArguments::List(FunctionArgumentList { duplicate_treatment: None, args: vec![FunctionArg::Unnamed(FunctionArgExpr::Expr( Expr::Identifier(Ident { value: "c12".to_string(), quote_style: None, span: Span::empty(), }), ))], clauses: vec![], }), null_treatment: None, filter: None, over: Some(WindowType::NamedWindow(Ident { value: "window1".to_string(), quote_style: None, span: Span::empty(), })), within_group: vec![], }), alias: Ident { value: "min1".to_string(), quote_style: None, span: Span::empty(), }, }, SelectItem::ExprWithAlias { expr: Expr::Function(Function { name: ObjectName::from(vec![Ident { value: "MAX".to_string(), quote_style: None, span: Span::empty(), }]), uses_odbc_syntax: false, parameters: FunctionArguments::None, args: FunctionArguments::List(FunctionArgumentList { duplicate_treatment: None, args: vec![FunctionArg::Unnamed(FunctionArgExpr::Expr( Expr::Identifier(Ident { value: "c12".to_string(), quote_style: None, span: Span::empty(), }), ))], clauses: vec![], }), null_treatment: None, filter: None, over: Some(WindowType::NamedWindow(Ident { value: "window2".to_string(), quote_style: None, span: Span::empty(), })), within_group: vec![], }), alias: Ident { value: "max1".to_string(), quote_style: None, span: Span::empty(), }, }, ], exclude: None, into: None, from: vec![TableWithJoins { relation: table_from_name(ObjectName::from(vec![Ident { value: "aggregate_test_100".to_string(), quote_style: None, span: Span::empty(), }])), joins: vec![], }], lateral_views: vec![], prewhere: None, selection: None, group_by: GroupByExpr::Expressions(vec![], vec![]), cluster_by: vec![], distribute_by: vec![], sort_by: vec![], having: None, named_window: vec![ NamedWindowDefinition( Ident { value: "window1".to_string(), quote_style: None, span: Span::empty(), }, NamedWindowExpr::WindowSpec(WindowSpec { window_name: None, partition_by: vec![], order_by: vec![OrderByExpr { expr: Expr::Identifier(Ident { value: "C12".to_string(), quote_style: None, span: Span::empty(), }), options: OrderByOptions { asc: None, nulls_first: None, }, with_fill: None, }], window_frame: None, }), ), NamedWindowDefinition( Ident { value: "window2".to_string(), quote_style: None, span: Span::empty(), }, NamedWindowExpr::WindowSpec(WindowSpec { window_name: None, partition_by: vec![Expr::Identifier(Ident { value: "C11".to_string(), quote_style: None, span: Span::empty(), })], order_by: vec![], window_frame: None, }), ), ], qualify: None, window_before_qualify: true, value_table_mode: None, connect_by: vec![], flavor: SelectFlavor::Standard, }; assert_eq!(actual_select_only, expected); } #[test] fn parse_window_and_qualify_clause() { let dialects = all_dialects_except(|d| { d.is_table_alias(&Keyword::WINDOW, &mut Parser::new(d)) || d.is_table_alias(&Keyword::QUALIFY, &mut Parser::new(d)) }); let sql = "SELECT \ MIN(c12) OVER window1 AS min1 \ FROM aggregate_test_100 \ QUALIFY ROW_NUMBER() OVER my_window \ WINDOW window1 AS (ORDER BY C12), \ window2 AS (PARTITION BY C11) \ ORDER BY C3"; dialects.verified_only_select(sql); let sql = "SELECT \ MIN(c12) OVER window1 AS min1 \ FROM aggregate_test_100 \ WINDOW window1 AS (ORDER BY C12), \ window2 AS (PARTITION BY C11) \ QUALIFY ROW_NUMBER() OVER my_window \ ORDER BY C3"; dialects.verified_only_select(sql); } #[test] fn parse_window_clause_named_window() { let sql = "SELECT * FROM mytable WINDOW window1 AS window2"; let Select { named_window, .. } = all_dialects_where(|d| d.supports_window_clause_named_window_reference()) .verified_only_select(sql); assert_eq!( vec![NamedWindowDefinition( Ident::new("window1"), NamedWindowExpr::NamedWindow(Ident::new("window2")) )], named_window ); } #[test] fn parse_aggregate_with_group_by() { let sql = "SELECT a, COUNT(1), MIN(b), MAX(b) FROM foo GROUP BY a"; let _ast = verified_only_select(sql); //TODO: assertions } #[test] fn parse_literal_integer() { let sql = "SELECT 1, -10, +20"; let select = verified_only_select(sql); assert_eq!(3, select.projection.len()); assert_eq!( &Expr::value(number("1")), expr_from_projection(&select.projection[0]), ); // negative literal is parsed as a - and expr assert_eq!( &UnaryOp { op: UnaryOperator::Minus, expr: Box::new(Expr::value(number("10"))) }, expr_from_projection(&select.projection[1]), ); // positive literal is parsed as a + and expr assert_eq!( &UnaryOp { op: UnaryOperator::Plus, expr: Box::new(Expr::value(number("20"))) }, expr_from_projection(&select.projection[2]), ) } #[test] fn parse_literal_decimal() { // These numbers were explicitly chosen to not roundtrip if represented as // f64s (i.e., as 64-bit binary floating point numbers). let sql = "SELECT 0.300000000000000004, 9007199254740993.0"; let select = verified_only_select(sql); assert_eq!(2, select.projection.len()); assert_eq!( &Expr::value(number("0.300000000000000004")), expr_from_projection(&select.projection[0]), ); assert_eq!( &Expr::value(number("9007199254740993.0")), expr_from_projection(&select.projection[1]), ) } #[test] fn parse_literal_string() { let sql = "SELECT 'one', N'national string', X'deadBEEF'"; let select = verified_only_select(sql); assert_eq!(3, select.projection.len()); assert_eq!( &Expr::Value((Value::SingleQuotedString("one".to_string())).with_empty_span()), expr_from_projection(&select.projection[0]) ); assert_eq!( &Expr::Value( (Value::NationalStringLiteral("national string".to_string())).with_empty_span() ), expr_from_projection(&select.projection[1]) ); assert_eq!( &Expr::Value((Value::HexStringLiteral("deadBEEF".to_string())).with_empty_span()), expr_from_projection(&select.projection[2]) ); one_statement_parses_to("SELECT x'deadBEEF'", "SELECT X'deadBEEF'"); one_statement_parses_to("SELECT n'national string'", "SELECT N'national string'"); } #[test] fn parse_literal_date() { let sql = "SELECT DATE '1999-01-01'"; let select = verified_only_select(sql); assert_eq!( &Expr::TypedString(TypedString { data_type: DataType::Date, value: ValueWithSpan { value: Value::SingleQuotedString("1999-01-01".into()), span: Span::empty(), }, uses_odbc_syntax: false }), expr_from_projection(only(&select.projection)), ); } #[test] fn parse_literal_time() { let sql = "SELECT TIME '01:23:34'"; let select = verified_only_select(sql); assert_eq!( &Expr::TypedString(TypedString { data_type: DataType::Time(None, TimezoneInfo::None), value: ValueWithSpan { value: Value::SingleQuotedString("01:23:34".into()), span: Span::empty(), }, uses_odbc_syntax: false }), expr_from_projection(only(&select.projection)), ); } #[test] fn parse_literal_datetime() { let sql = "SELECT DATETIME '1999-01-01 01:23:34.45'"; let select = verified_only_select(sql); assert_eq!( &Expr::TypedString(TypedString { data_type: DataType::Datetime(None), value: ValueWithSpan { value: Value::SingleQuotedString("1999-01-01 01:23:34.45".into()), span: Span::empty(), }, uses_odbc_syntax: false }), expr_from_projection(only(&select.projection)), ); } #[test] fn parse_literal_timestamp_without_time_zone() { let sql = "SELECT TIMESTAMP '1999-01-01 01:23:34'"; let select = verified_only_select(sql); assert_eq!( &Expr::TypedString(TypedString { data_type: DataType::Timestamp(None, TimezoneInfo::None), value: ValueWithSpan { value: Value::SingleQuotedString("1999-01-01 01:23:34".into()), span: Span::empty(), }, uses_odbc_syntax: false }), expr_from_projection(only(&select.projection)), ); one_statement_parses_to("SELECT TIMESTAMP '1999-01-01 01:23:34'", sql); } #[test] fn parse_literal_timestamp_with_time_zone() { let sql = "SELECT TIMESTAMPTZ '1999-01-01 01:23:34Z'"; let select = verified_only_select(sql); assert_eq!( &Expr::TypedString(TypedString { data_type: DataType::Timestamp(None, TimezoneInfo::Tz), value: ValueWithSpan { value: Value::SingleQuotedString("1999-01-01 01:23:34Z".into()), span: Span::empty(), }, uses_odbc_syntax: false }), expr_from_projection(only(&select.projection)), ); one_statement_parses_to("SELECT TIMESTAMPTZ '1999-01-01 01:23:34Z'", sql); } #[test] fn parse_interval_all() { // these intervals expressions all work with both variants of INTERVAL let sql = "SELECT INTERVAL '1-1' YEAR TO MONTH"; let select = verified_only_select(sql); assert_eq!( &Expr::Interval(Interval { value: Box::new(Expr::Value( (Value::SingleQuotedString(String::from("1-1"))).with_empty_span() )), leading_field: Some(DateTimeField::Year), leading_precision: None, last_field: Some(DateTimeField::Month), fractional_seconds_precision: None, }), expr_from_projection(only(&select.projection)), ); let sql = "SELECT INTERVAL '01:01.01' MINUTE (5) TO SECOND (5)"; let select = verified_only_select(sql); assert_eq!( &Expr::Interval(Interval { value: Box::new(Expr::Value( (Value::SingleQuotedString(String::from("01:01.01"))).with_empty_span() )), leading_field: Some(DateTimeField::Minute), leading_precision: Some(5), last_field: Some(DateTimeField::Second), fractional_seconds_precision: Some(5), }), expr_from_projection(only(&select.projection)), ); let sql = "SELECT INTERVAL '1' SECOND (5, 4)"; let select = verified_only_select(sql); assert_eq!( &Expr::Interval(Interval { value: Box::new(Expr::Value( (Value::SingleQuotedString(String::from("1"))).with_empty_span() )), leading_field: Some(DateTimeField::Second), leading_precision: Some(5), last_field: None, fractional_seconds_precision: Some(4), }), expr_from_projection(only(&select.projection)), ); let sql = "SELECT INTERVAL '10' HOUR"; let select = verified_only_select(sql); assert_eq!( &Expr::Interval(Interval { value: Box::new(Expr::Value( (Value::SingleQuotedString(String::from("10"))).with_empty_span() )), leading_field: Some(DateTimeField::Hour), leading_precision: None, last_field: None, fractional_seconds_precision: None, }), expr_from_projection(only(&select.projection)), ); let sql = "SELECT INTERVAL 5 DAY"; let select = verified_only_select(sql); assert_eq!( &Expr::Interval(Interval { value: Box::new(Expr::value(number("5"))), leading_field: Some(DateTimeField::Day), leading_precision: None, last_field: None, fractional_seconds_precision: None, }), expr_from_projection(only(&select.projection)), ); let sql = "SELECT INTERVAL 5 DAYS"; let select = verified_only_select(sql); assert_eq!( &Expr::Interval(Interval { value: Box::new(Expr::value(number("5"))), leading_field: Some(DateTimeField::Days), leading_precision: None, last_field: None, fractional_seconds_precision: None, }), expr_from_projection(only(&select.projection)), ); let sql = "SELECT INTERVAL '10' HOUR (1)"; let select = verified_only_select(sql); assert_eq!( &Expr::Interval(Interval { value: Box::new(Expr::Value( (Value::SingleQuotedString(String::from("10"))).with_empty_span() )), leading_field: Some(DateTimeField::Hour), leading_precision: Some(1), last_field: None, fractional_seconds_precision: None, }), expr_from_projection(only(&select.projection)), ); let result = parse_sql_statements("SELECT INTERVAL '1' SECOND TO SECOND"); assert_eq!( ParserError::ParserError("Expected: end of statement, found: SECOND".to_string()), result.unwrap_err(), ); let result = parse_sql_statements("SELECT INTERVAL '10' HOUR (1) TO HOUR (2)"); assert_eq!( ParserError::ParserError("Expected: end of statement, found: (".to_string()), result.unwrap_err(), ); verified_only_select("SELECT INTERVAL '1' YEAR"); verified_only_select("SELECT INTERVAL '1' MONTH"); verified_only_select("SELECT INTERVAL '1' WEEK"); verified_only_select("SELECT INTERVAL '1' DAY"); verified_only_select("SELECT INTERVAL '1' HOUR"); verified_only_select("SELECT INTERVAL '1' MINUTE"); verified_only_select("SELECT INTERVAL '1' SECOND"); verified_only_select("SELECT INTERVAL '1' YEARS"); verified_only_select("SELECT INTERVAL '1' MONTHS"); verified_only_select("SELECT INTERVAL '1' WEEKS"); verified_only_select("SELECT INTERVAL '1' DAYS"); verified_only_select("SELECT INTERVAL '1' HOURS"); verified_only_select("SELECT INTERVAL '1' MINUTES"); verified_only_select("SELECT INTERVAL '1' SECONDS"); verified_only_select("SELECT INTERVAL '1' YEAR TO MONTH"); verified_only_select("SELECT INTERVAL '1' DAY TO HOUR"); verified_only_select("SELECT INTERVAL '1' DAY TO MINUTE"); verified_only_select("SELECT INTERVAL '1' DAY TO SECOND"); verified_only_select("SELECT INTERVAL '1' HOUR TO MINUTE"); verified_only_select("SELECT INTERVAL '1' HOUR TO SECOND"); verified_only_select("SELECT INTERVAL '1' MINUTE TO SECOND"); verified_only_select("SELECT INTERVAL 1 YEAR"); verified_only_select("SELECT INTERVAL 1 MONTH"); verified_only_select("SELECT INTERVAL 1 WEEK"); verified_only_select("SELECT INTERVAL 1 DAY"); verified_only_select("SELECT INTERVAL 1 HOUR"); verified_only_select("SELECT INTERVAL 1 MINUTE"); verified_only_select("SELECT INTERVAL 1 SECOND"); verified_only_select("SELECT INTERVAL 1 YEARS"); verified_only_select("SELECT INTERVAL 1 MONTHS"); verified_only_select("SELECT INTERVAL 1 WEEKS"); verified_only_select("SELECT INTERVAL 1 DAYS"); verified_only_select("SELECT INTERVAL 1 HOURS"); verified_only_select("SELECT INTERVAL 1 MINUTES"); verified_only_select("SELECT INTERVAL 1 SECONDS"); verified_only_select( "SELECT '2 years 15 months 100 weeks 99 hours 123456789 milliseconds'::INTERVAL", ); } #[test] fn parse_interval_dont_require_unit() { let dialects = all_dialects_except(|d| d.require_interval_qualifier()); let sql = "SELECT INTERVAL '1 DAY'"; let select = dialects.verified_only_select(sql); assert_eq!( &Expr::Interval(Interval { value: Box::new(Expr::Value( (Value::SingleQuotedString(String::from("1 DAY"))).with_empty_span() )), leading_field: None, leading_precision: None, last_field: None, fractional_seconds_precision: None, }), expr_from_projection(only(&select.projection)), ); dialects.verified_only_select("SELECT INTERVAL '1 YEAR'"); dialects.verified_only_select("SELECT INTERVAL '1 MONTH'"); dialects.verified_only_select("SELECT INTERVAL '1 DAY'"); dialects.verified_only_select("SELECT INTERVAL '1 HOUR'"); dialects.verified_only_select("SELECT INTERVAL '1 MINUTE'"); dialects.verified_only_select("SELECT INTERVAL '1 SECOND'"); } #[test] fn parse_interval_require_unit() { let dialects = all_dialects_where(|d| d.require_interval_qualifier()); let sql = "SELECT INTERVAL '1 DAY'"; let err = dialects.parse_sql_statements(sql).unwrap_err(); assert_eq!( err.to_string(), "sql parser error: INTERVAL requires a unit after the literal value" ) } #[test] fn parse_interval_require_qualifier() { let dialects = all_dialects_where(|d| d.require_interval_qualifier()); let sql = "SELECT INTERVAL 1 + 1 DAY"; let select = dialects.verified_only_select(sql); assert_eq!( expr_from_projection(only(&select.projection)), &Expr::Interval(Interval { value: Box::new(Expr::BinaryOp { left: Box::new(Expr::value(number("1"))), op: BinaryOperator::Plus, right: Box::new(Expr::value(number("1"))), }), leading_field: Some(DateTimeField::Day), leading_precision: None, last_field: None, fractional_seconds_precision: None, }), ); let sql = "SELECT INTERVAL '1' + '1' DAY"; let select = dialects.verified_only_select(sql); assert_eq!( expr_from_projection(only(&select.projection)), &Expr::Interval(Interval { value: Box::new(Expr::BinaryOp { left: Box::new(Expr::Value( (Value::SingleQuotedString("1".to_string())).with_empty_span() )), op: BinaryOperator::Plus, right: Box::new(Expr::Value( (Value::SingleQuotedString("1".to_string())).with_empty_span() )), }), leading_field: Some(DateTimeField::Day), leading_precision: None, last_field: None, fractional_seconds_precision: None, }), ); let sql = "SELECT INTERVAL '1' + '2' - '3' DAY"; let select = dialects.verified_only_select(sql); assert_eq!( expr_from_projection(only(&select.projection)), &Expr::Interval(Interval { value: Box::new(Expr::BinaryOp { left: Box::new(Expr::BinaryOp { left: Box::new(Expr::Value( (Value::SingleQuotedString("1".to_string())).with_empty_span() )), op: BinaryOperator::Plus, right: Box::new(Expr::Value( (Value::SingleQuotedString("2".to_string())).with_empty_span() )), }), op: BinaryOperator::Minus, right: Box::new(Expr::Value( (Value::SingleQuotedString("3".to_string())).with_empty_span() )), }), leading_field: Some(DateTimeField::Day), leading_precision: None, last_field: None, fractional_seconds_precision: None, }), ); } #[test] fn parse_interval_disallow_interval_expr() { let dialects = all_dialects_except(|d| d.require_interval_qualifier()); let sql = "SELECT INTERVAL '1 DAY'"; let select = dialects.verified_only_select(sql); assert_eq!( expr_from_projection(only(&select.projection)), &Expr::Interval(Interval { value: Box::new(Expr::Value( (Value::SingleQuotedString(String::from("1 DAY"))).with_empty_span() )), leading_field: None, leading_precision: None, last_field: None, fractional_seconds_precision: None, }), ); dialects.verified_only_select("SELECT INTERVAL '1 YEAR'"); dialects.verified_only_select("SELECT INTERVAL '1 YEAR' AS one_year"); dialects.one_statement_parses_to( "SELECT INTERVAL '1 YEAR' one_year", "SELECT INTERVAL '1 YEAR' AS one_year", ); let sql = "SELECT INTERVAL '1 DAY' > INTERVAL '1 SECOND'"; let select = dialects.verified_only_select(sql); assert_eq!( expr_from_projection(only(&select.projection)), &Expr::BinaryOp { left: Box::new(Expr::Interval(Interval { value: Box::new(Expr::Value( (Value::SingleQuotedString(String::from("1 DAY"))).with_empty_span() )), leading_field: None, leading_precision: None, last_field: None, fractional_seconds_precision: None, })), op: BinaryOperator::Gt, right: Box::new(Expr::Interval(Interval { value: Box::new(Expr::Value( (Value::SingleQuotedString(String::from("1 SECOND"))).with_empty_span() )), leading_field: None, leading_precision: None, last_field: None, fractional_seconds_precision: None, })) } ); } #[test] fn interval_disallow_interval_expr_gt() { let dialects = all_dialects_except(|d| d.require_interval_qualifier()); let expr = dialects.verified_expr("INTERVAL '1 second' > x"); assert_eq!( expr, Expr::BinaryOp { left: Box::new(Expr::Interval(Interval { value: Box::new(Expr::Value( (Value::SingleQuotedString("1 second".to_string())).with_empty_span() )), leading_field: None, leading_precision: None, last_field: None, fractional_seconds_precision: None, },)), op: BinaryOperator::Gt, right: Box::new(Expr::Identifier(Ident { value: "x".to_string(), quote_style: None, span: Span::empty(), })), } ) } #[test] fn interval_disallow_interval_expr_double_colon() { let dialects = all_dialects_except(|d| d.require_interval_qualifier()); let expr = dialects.verified_expr("INTERVAL '1 second'::TEXT"); assert_eq!( expr, Expr::Cast { kind: CastKind::DoubleColon, expr: Box::new(Expr::Interval(Interval { value: Box::new(Expr::Value( (Value::SingleQuotedString("1 second".to_string())).with_empty_span() )), leading_field: None, leading_precision: None, last_field: None, fractional_seconds_precision: None, })), data_type: DataType::Text, array: false, format: None, } ) } #[test] fn parse_text_type_modifier_double_colon_cast() { let expr = verified_expr("ID::TEXT(16777216)"); assert_eq!( expr, Expr::Cast { kind: CastKind::DoubleColon, expr: Box::new(Expr::Identifier(Ident::new("ID"))), data_type: DataType::Custom( ObjectName::from(vec![Ident::new("TEXT")]), vec!["16777216".to_string()] ), array: false, format: None, } ); } #[test] fn parse_interval_and_or_xor() { let sql = "SELECT col FROM test \ WHERE d3_date > d1_date + INTERVAL '5 days' \ AND d2_date > d1_date + INTERVAL '3 days'"; let dialects = all_dialects_except(|d| d.require_interval_qualifier()); let actual_ast = dialects.parse_sql_statements(sql).unwrap(); let expected_ast = vec![Statement::Query(Box::new(Query { with: None, body: Box::new(SetExpr::Select(Box::new(Select { select_token: AttachedToken::empty(), optimizer_hints: vec![], distinct: None, select_modifiers: None, top: None, top_before_distinct: false, projection: vec![UnnamedExpr(Expr::Identifier(Ident { value: "col".to_string(), quote_style: None, span: Span::empty(), }))], exclude: None, into: None, from: vec![TableWithJoins { relation: table_from_name(ObjectName::from(vec![Ident { value: "test".to_string(), quote_style: None, span: Span::empty(), }])), joins: vec![], }], lateral_views: vec![], prewhere: None, selection: Some(Expr::BinaryOp { left: Box::new(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident { value: "d3_date".to_string(), quote_style: None, span: Span::empty(), })), op: BinaryOperator::Gt, right: Box::new(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident { value: "d1_date".to_string(), quote_style: None, span: Span::empty(), })), op: BinaryOperator::Plus, right: Box::new(Expr::Interval(Interval { value: Box::new(Expr::Value( (Value::SingleQuotedString("5 days".to_string())).with_empty_span(), )), leading_field: None, leading_precision: None, last_field: None, fractional_seconds_precision: None, })), }), }), op: BinaryOperator::And, right: Box::new(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident { value: "d2_date".to_string(), quote_style: None, span: Span::empty(), })), op: BinaryOperator::Gt, right: Box::new(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident { value: "d1_date".to_string(), quote_style: None, span: Span::empty(), })), op: BinaryOperator::Plus, right: Box::new(Expr::Interval(Interval { value: Box::new(Expr::Value( (Value::SingleQuotedString("3 days".to_string())).with_empty_span(), )), leading_field: None, leading_precision: None, last_field: None, fractional_seconds_precision: None, })), }), }), }), group_by: GroupByExpr::Expressions(vec![], vec![]), cluster_by: vec![], distribute_by: vec![], sort_by: vec![], having: None, named_window: vec![], qualify: None, window_before_qualify: false, value_table_mode: None, connect_by: vec![], flavor: SelectFlavor::Standard, }))), order_by: None, limit_clause: None, fetch: None, locks: vec![], for_clause: None, settings: None, format_clause: None, pipe_operators: vec![], }))]; assert_eq!(actual_ast, expected_ast); dialects.verified_stmt( "SELECT col FROM test \ WHERE d3_date > d1_date + INTERVAL '5 days' \ AND d2_date > d1_date + INTERVAL '3 days'", ); dialects.verified_stmt( "SELECT col FROM test \ WHERE d3_date > d1_date + INTERVAL '5 days' \ OR d2_date > d1_date + INTERVAL '3 days'", ); dialects.verified_stmt( "SELECT col FROM test \ WHERE d3_date > d1_date + INTERVAL '5 days' \ XOR d2_date > d1_date + INTERVAL '3 days'", ); } #[test] fn parse_at_timezone() { let zero = Expr::value(number("0")); let sql = "SELECT FROM_UNIXTIME(0) AT TIME ZONE 'UTC-06:00' FROM t"; let select = verified_only_select(sql); assert_eq!( &Expr::AtTimeZone { timestamp: Box::new(call("FROM_UNIXTIME", [zero.clone()])), time_zone: Box::new(Expr::Value( (Value::SingleQuotedString("UTC-06:00".to_string())).with_empty_span() )), }, expr_from_projection(only(&select.projection)), ); let sql = r#"SELECT DATE_FORMAT(FROM_UNIXTIME(0) AT TIME ZONE 'UTC-06:00', '%Y-%m-%dT%H') AS "hour" FROM t"#; let select = verified_only_select(sql); assert_eq!( &SelectItem::ExprWithAlias { expr: call( "DATE_FORMAT", [ Expr::AtTimeZone { timestamp: Box::new(call("FROM_UNIXTIME", [zero])), time_zone: Box::new(Expr::Value( (Value::SingleQuotedString("UTC-06:00".to_string())).with_empty_span() )), }, Expr::Value( (Value::SingleQuotedString("%Y-%m-%dT%H".to_string())).with_empty_span() ) ] ), alias: Ident { value: "hour".to_string(), quote_style: Some('"'), span: Span::empty(), }, }, only(&select.projection), ); } #[test] fn parse_json_keyword() { let sql = r#"SELECT JSON '{ "id": 10, "type": "fruit", "name": "apple", "on_menu": true, "recipes": { "salads": [ { "id": 2001, "type": "Walnut Apple Salad" }, { "id": 2002, "type": "Apple Spinach Salad" } ], "desserts": [ { "id": 3001, "type": "Apple Pie" }, { "id": 3002, "type": "Apple Scones" }, { "id": 3003, "type": "Apple Crumble" } ] } }'"#; let select = verified_only_select(sql); assert_eq!( &Expr::TypedString(TypedString { data_type: DataType::JSON, value: ValueWithSpan { value: Value::SingleQuotedString( r#"{ "id": 10, "type": "fruit", "name": "apple", "on_menu": true, "recipes": { "salads": [ { "id": 2001, "type": "Walnut Apple Salad" }, { "id": 2002, "type": "Apple Spinach Salad" } ], "desserts": [ { "id": 3001, "type": "Apple Pie" }, { "id": 3002, "type": "Apple Scones" }, { "id": 3003, "type": "Apple Crumble" } ] } }"# .to_string() ), span: Span::empty(), }, uses_odbc_syntax: false, }), expr_from_projection(only(&select.projection)), ); } #[test] fn parse_typed_strings() { let expr = verified_expr(r#"JSON '{"foo":"bar"}'"#); assert_eq!( Expr::TypedString(TypedString { data_type: DataType::JSON, value: ValueWithSpan { value: Value::SingleQuotedString(r#"{"foo":"bar"}"#.into()), span: Span::empty(), }, uses_odbc_syntax: false }), expr ); if let Expr::TypedString(TypedString { data_type, value, uses_odbc_syntax: false, }) = expr { assert_eq!(DataType::JSON, data_type); assert_eq!(r#"{"foo":"bar"}"#, value.into_string().unwrap()); } } #[test] fn parse_bignumeric_keyword() { let sql = r#"SELECT BIGNUMERIC '0'"#; let select = verified_only_select(sql); assert_eq!( &Expr::TypedString(TypedString { data_type: DataType::BigNumeric(ExactNumberInfo::None), value: ValueWithSpan { value: Value::SingleQuotedString(r#"0"#.into()), span: Span::empty(), }, uses_odbc_syntax: false }), expr_from_projection(only(&select.projection)), ); verified_stmt("SELECT BIGNUMERIC '0'"); let sql = r#"SELECT BIGNUMERIC '123456'"#; let select = verified_only_select(sql); assert_eq!( &Expr::TypedString(TypedString { data_type: DataType::BigNumeric(ExactNumberInfo::None), value: ValueWithSpan { value: Value::SingleQuotedString(r#"123456"#.into()), span: Span::empty(), }, uses_odbc_syntax: false }), expr_from_projection(only(&select.projection)), ); verified_stmt("SELECT BIGNUMERIC '123456'"); let sql = r#"SELECT BIGNUMERIC '-3.14'"#; let select = verified_only_select(sql); assert_eq!( &Expr::TypedString(TypedString { data_type: DataType::BigNumeric(ExactNumberInfo::None), value: ValueWithSpan { value: Value::SingleQuotedString(r#"-3.14"#.into()), span: Span::empty(), }, uses_odbc_syntax: false }), expr_from_projection(only(&select.projection)), ); verified_stmt("SELECT BIGNUMERIC '-3.14'"); let sql = r#"SELECT BIGNUMERIC '-0.54321'"#; let select = verified_only_select(sql); assert_eq!( &Expr::TypedString(TypedString { data_type: DataType::BigNumeric(ExactNumberInfo::None), value: ValueWithSpan { value: Value::SingleQuotedString(r#"-0.54321"#.into()), span: Span::empty(), }, uses_odbc_syntax: false }), expr_from_projection(only(&select.projection)), ); verified_stmt("SELECT BIGNUMERIC '-0.54321'"); let sql = r#"SELECT BIGNUMERIC '1.23456e05'"#; let select = verified_only_select(sql); assert_eq!( &Expr::TypedString(TypedString { data_type: DataType::BigNumeric(ExactNumberInfo::None), value: ValueWithSpan { value: Value::SingleQuotedString(r#"1.23456e05"#.into()), span: Span::empty(), }, uses_odbc_syntax: false }), expr_from_projection(only(&select.projection)), ); verified_stmt("SELECT BIGNUMERIC '1.23456e05'"); let sql = r#"SELECT BIGNUMERIC '-9.876e-3'"#; let select = verified_only_select(sql); assert_eq!( &Expr::TypedString(TypedString { data_type: DataType::BigNumeric(ExactNumberInfo::None), value: ValueWithSpan { value: Value::SingleQuotedString(r#"-9.876e-3"#.into()), span: Span::empty(), }, uses_odbc_syntax: false }), expr_from_projection(only(&select.projection)), ); verified_stmt("SELECT BIGNUMERIC '-9.876e-3'"); } #[test] fn parse_simple_math_expr_plus() { let sql = "SELECT a + b, 2 + a, 2.5 + a, a_f + b_f, 2 + a_f, 2.5 + a_f FROM c"; verified_only_select(sql); } #[test] fn parse_simple_math_expr_minus() { let sql = "SELECT a - b, 2 - a, 2.5 - a, a_f - b_f, 2 - a_f, 2.5 - a_f FROM c"; verified_only_select(sql); } #[test] fn parse_table_function() { let select = verified_only_select("SELECT * FROM TABLE(FUN('1')) AS a"); match only(select.from).relation { TableFactor::TableFunction { expr, alias } => { assert_eq!( call( "FUN", [Expr::Value( (Value::SingleQuotedString("1".to_owned())).with_empty_span() )], ), expr ); assert_eq!(alias, table_alias(true, "a")) } _ => panic!("Expecting TableFactor::TableFunction"), } let res = parse_sql_statements("SELECT * FROM TABLE '1' AS a"); assert_eq!( ParserError::ParserError("Expected: (, found: \'1\'".to_string()), res.unwrap_err() ); let res = parse_sql_statements("SELECT * FROM TABLE (FUN(a) AS a"); assert_eq!( ParserError::ParserError("Expected: ), found: AS".to_string()), res.unwrap_err() ); } #[test] fn parse_select_with_alias_and_column_defs() { let sql = r#"SELECT * FROM jsonb_to_record('{"a": "x", "b": 2}'::JSONB) AS x (a TEXT, b INT)"#; let select = verified_only_select(sql); match only(&select.from) { TableWithJoins { relation: TableFactor::Table { alias: Some(alias), .. }, .. } => { assert_eq!(alias.name.value, "x"); assert_eq!( alias.columns, vec![ TableAliasColumnDef { name: Ident::new("a"), data_type: Some(DataType::Text), }, TableAliasColumnDef { name: Ident::new("b"), data_type: Some(DataType::Int(None)), }, ] ); } _ => unreachable!( "Expecting only TableWithJoins with TableFactor::Table, got {:#?}", select.from ), } } #[test] fn parse_unnest() { let sql = "SELECT UNNEST(make_array(1, 2, 3))"; one_statement_parses_to(sql, sql); let sql = "SELECT UNNEST(make_array(1, 2, 3), make_array(4, 5))"; one_statement_parses_to(sql, sql); } #[test] fn parse_unnest_in_from_clause() { fn chk( array_exprs: &str, alias: bool, with_offset: bool, with_offset_alias: bool, dialects: &TestedDialects, want: Vec, ) { let sql = &format!( "SELECT * FROM UNNEST({}){}{}{}", array_exprs, if alias { " AS numbers" } else { "" }, if with_offset { " WITH OFFSET" } else { "" }, if with_offset_alias { " AS with_offset_alias" } else { "" }, ); let select = dialects.verified_only_select(sql); assert_eq!(select.from, want); } let dialects = TestedDialects::new(vec![ Box::new(BigQueryDialect {}), Box::new(GenericDialect {}), ]); // 1. both Alias and WITH OFFSET clauses. chk( "expr", true, true, false, &dialects, vec![TableWithJoins { relation: TableFactor::UNNEST { alias: table_alias(true, "numbers"), array_exprs: vec![Expr::Identifier(Ident::new("expr"))], with_offset: true, with_offset_alias: None, with_ordinality: false, }, joins: vec![], }], ); // 2. neither Alias nor WITH OFFSET clause. chk( "expr", false, false, false, &dialects, vec![TableWithJoins { relation: TableFactor::UNNEST { alias: None, array_exprs: vec![Expr::Identifier(Ident::new("expr"))], with_offset: false, with_offset_alias: None, with_ordinality: false, }, joins: vec![], }], ); // 3. Alias but no WITH OFFSET clause. chk( "expr", false, true, false, &dialects, vec![TableWithJoins { relation: TableFactor::UNNEST { alias: None, array_exprs: vec![Expr::Identifier(Ident::new("expr"))], with_offset: true, with_offset_alias: None, with_ordinality: false, }, joins: vec![], }], ); // 4. WITH OFFSET but no Alias. chk( "expr", true, false, false, &dialects, vec![TableWithJoins { relation: TableFactor::UNNEST { alias: table_alias(true, "numbers"), array_exprs: vec![Expr::Identifier(Ident::new("expr"))], with_offset: false, with_offset_alias: None, with_ordinality: false, }, joins: vec![], }], ); // 5. Simple array chk( "make_array(1, 2, 3)", false, false, false, &dialects, vec![TableWithJoins { relation: TableFactor::UNNEST { alias: None, array_exprs: vec![call( "make_array", [ Expr::value(number("1")), Expr::value(number("2")), Expr::value(number("3")), ], )], with_offset: false, with_offset_alias: None, with_ordinality: false, }, joins: vec![], }], ); // 6. Multiple arrays chk( "make_array(1, 2, 3), make_array(5, 6)", false, false, false, &dialects, vec![TableWithJoins { relation: TableFactor::UNNEST { alias: None, array_exprs: vec![ call( "make_array", [ Expr::value(number("1")), Expr::value(number("2")), Expr::value(number("3")), ], ), call( "make_array", [Expr::value(number("5")), Expr::value(number("6"))], ), ], with_offset: false, with_offset_alias: None, with_ordinality: false, }, joins: vec![], }], ) } #[test] fn parse_parens() { use self::BinaryOperator::*; use self::Expr::*; let sql = "(a + b) - (c + d)"; assert_eq!( BinaryOp { left: Box::new(Nested(Box::new(BinaryOp { left: Box::new(Identifier(Ident::new("a"))), op: Plus, right: Box::new(Identifier(Ident::new("b"))), }))), op: Minus, right: Box::new(Nested(Box::new(BinaryOp { left: Box::new(Identifier(Ident::new("c"))), op: Plus, right: Box::new(Identifier(Ident::new("d"))), }))), }, verified_expr(sql) ); } #[test] fn parse_searched_case_expr() { let sql = "SELECT CASE WHEN bar IS NULL THEN 'null' WHEN bar = 0 THEN '=0' WHEN bar >= 0 THEN '>=0' ELSE '<0' END FROM foo"; use self::BinaryOperator::*; use self::Expr::{BinaryOp, Case, Identifier, IsNull}; let select = verified_only_select(sql); assert_eq!( &Case { case_token: AttachedToken::empty(), end_token: AttachedToken::empty(), operand: None, conditions: vec![ CaseWhen { condition: IsNull(Box::new(Identifier(Ident::new("bar")))), result: Expr::value(Value::SingleQuotedString("null".to_string())), }, CaseWhen { condition: BinaryOp { left: Box::new(Identifier(Ident::new("bar"))), op: Eq, right: Box::new(Expr::value(number("0"))), }, result: Expr::value(Value::SingleQuotedString("=0".to_string())), }, CaseWhen { condition: BinaryOp { left: Box::new(Identifier(Ident::new("bar"))), op: GtEq, right: Box::new(Expr::value(number("0"))), }, result: Expr::value(Value::SingleQuotedString(">=0".to_string())), }, ], else_result: Some(Box::new(Expr::value(Value::SingleQuotedString( "<0".to_string() )))), }, expr_from_projection(only(&select.projection)), ); } #[test] fn parse_simple_case_expr() { // ANSI calls a CASE expression with an operand "" let sql = "SELECT CASE foo WHEN 1 THEN 'Y' ELSE 'N' END"; let select = verified_only_select(sql); use self::Expr::{Case, Identifier}; assert_eq!( &Case { case_token: AttachedToken::empty(), end_token: AttachedToken::empty(), operand: Some(Box::new(Identifier(Ident::new("foo")))), conditions: vec![CaseWhen { condition: Expr::value(number("1")), result: Expr::value(Value::SingleQuotedString("Y".to_string())), }], else_result: Some(Box::new(Expr::value(Value::SingleQuotedString( "N".to_string() )))), }, expr_from_projection(only(&select.projection)), ); } #[test] fn parse_from_advanced() { let sql = "SELECT * FROM fn(1, 2) AS foo, schema.bar AS bar WITH (NOLOCK)"; let _select = verified_only_select(sql); } #[test] fn parse_nullary_table_valued_function() { let sql = "SELECT * FROM fn()"; let _select = verified_only_select(sql); } #[test] fn parse_implicit_join() { let sql = "SELECT * FROM t1, t2"; let select = verified_only_select(sql); assert_eq!( vec![ TableWithJoins { relation: table_from_name(ObjectName::from(vec!["t1".into()])), joins: vec![], }, TableWithJoins { relation: table_from_name(ObjectName::from(vec!["t2".into()])), joins: vec![], }, ], select.from, ); let sql = "SELECT * FROM t1a NATURAL JOIN t1b, t2a NATURAL JOIN t2b"; let select = verified_only_select(sql); assert_eq!( vec![ TableWithJoins { relation: table_from_name(ObjectName::from(vec!["t1a".into()])), joins: vec![Join { relation: table_from_name(ObjectName::from(vec!["t1b".into()])), global: false, join_operator: JoinOperator::Join(JoinConstraint::Natural), }], }, TableWithJoins { relation: table_from_name(ObjectName::from(vec!["t2a".into()])), joins: vec![Join { relation: table_from_name(ObjectName::from(vec!["t2b".into()])), global: false, join_operator: JoinOperator::Join(JoinConstraint::Natural), }], }, ], select.from, ); } #[test] fn parse_cross_join() { let sql = "SELECT * FROM t1 CROSS JOIN t2"; let select = verified_only_select(sql); assert_eq!( Join { relation: table_from_name(ObjectName::from(vec![Ident::new("t2")])), global: false, join_operator: JoinOperator::CrossJoin(JoinConstraint::None), }, only(only(select.from).joins), ); } #[test] fn parse_cross_join_constraint() { fn join_with_constraint(constraint: JoinConstraint) -> Join { Join { relation: table_from_name(ObjectName::from(vec![Ident::new("t2")])), global: false, join_operator: JoinOperator::CrossJoin(constraint), } } fn test_constraint(sql: &str, constraint: JoinConstraint) { let dialect = all_dialects_where(|d| d.supports_cross_join_constraint()); let select = dialect.verified_only_select(sql); assert_eq!( join_with_constraint(constraint), only(only(select.from).joins), ); } test_constraint( "SELECT * FROM t1 CROSS JOIN t2 ON a = b", JoinConstraint::On(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("a"))), op: BinaryOperator::Eq, right: Box::new(Expr::Identifier(Ident::new("b"))), }), ); test_constraint( "SELECT * FROM t1 CROSS JOIN t2 USING(a)", JoinConstraint::Using(vec![ObjectName::from(vec![Ident::new("a")])]), ); } #[test] fn parse_joins_on() { fn join_with_constraint( relation: impl Into, alias: Option, global: bool, f: impl Fn(JoinConstraint) -> JoinOperator, ) -> Join { Join { relation: TableFactor::Table { name: ObjectName::from(vec![Ident::new(relation.into())]), alias, args: None, with_hints: vec![], version: None, partitions: vec![], with_ordinality: false, json_path: None, sample: None, index_hints: vec![], }, global, join_operator: f(JoinConstraint::On(Expr::BinaryOp { left: Box::new(Expr::Identifier("c1".into())), op: BinaryOperator::Eq, right: Box::new(Expr::Identifier("c2".into())), })), } } // Test parsing of aliases assert_eq!( only(&verified_only_select("SELECT * FROM t1 JOIN t2 AS foo ON c1 = c2").from).joins, vec![join_with_constraint( "t2", table_alias(true, "foo"), false, JoinOperator::Join, )] ); one_statement_parses_to( "SELECT * FROM t1 JOIN t2 foo ON c1 = c2", "SELECT * FROM t1 JOIN t2 foo ON c1 = c2", ); // Test parsing of different join operators assert_eq!( only(&verified_only_select("SELECT * FROM t1 JOIN t2 ON c1 = c2").from).joins, vec![join_with_constraint("t2", None, false, JoinOperator::Join)] ); assert_eq!( only(&verified_only_select("SELECT * FROM t1 INNER JOIN t2 ON c1 = c2").from).joins, vec![join_with_constraint("t2", None, false, JoinOperator::Inner)] ); assert_eq!( only(&verified_only_select("SELECT * FROM t1 LEFT JOIN t2 ON c1 = c2").from).joins, vec![join_with_constraint("t2", None, false, JoinOperator::Left)] ); assert_eq!( only(&verified_only_select("SELECT * FROM t1 LEFT OUTER JOIN t2 ON c1 = c2").from).joins, vec![join_with_constraint( "t2", None, false, JoinOperator::LeftOuter )] ); assert_eq!( only(&verified_only_select("SELECT * FROM t1 RIGHT JOIN t2 ON c1 = c2").from).joins, vec![join_with_constraint("t2", None, false, JoinOperator::Right)] ); assert_eq!( only(&verified_only_select("SELECT * FROM t1 RIGHT OUTER JOIN t2 ON c1 = c2").from).joins, vec![join_with_constraint( "t2", None, false, JoinOperator::RightOuter )] ); assert_eq!( only(&verified_only_select("SELECT * FROM t1 SEMI JOIN t2 ON c1 = c2").from).joins, vec![join_with_constraint("t2", None, false, JoinOperator::Semi)] ); assert_eq!( only(&verified_only_select("SELECT * FROM t1 LEFT SEMI JOIN t2 ON c1 = c2").from).joins, vec![join_with_constraint( "t2", None, false, JoinOperator::LeftSemi )] ); assert_eq!( only(&verified_only_select("SELECT * FROM t1 RIGHT SEMI JOIN t2 ON c1 = c2").from).joins, vec![join_with_constraint( "t2", None, false, JoinOperator::RightSemi )] ); assert_eq!( only(&verified_only_select("SELECT * FROM t1 ANTI JOIN t2 ON c1 = c2").from).joins, vec![join_with_constraint("t2", None, false, JoinOperator::Anti)] ); assert_eq!( only(&verified_only_select("SELECT * FROM t1 LEFT ANTI JOIN t2 ON c1 = c2").from).joins, vec![join_with_constraint( "t2", None, false, JoinOperator::LeftAnti )] ); assert_eq!( only(&verified_only_select("SELECT * FROM t1 RIGHT ANTI JOIN t2 ON c1 = c2").from).joins, vec![join_with_constraint( "t2", None, false, JoinOperator::RightAnti )] ); assert_eq!( only(&verified_only_select("SELECT * FROM t1 FULL JOIN t2 ON c1 = c2").from).joins, vec![join_with_constraint( "t2", None, false, JoinOperator::FullOuter )] ); assert_eq!( only(&verified_only_select("SELECT * FROM t1 GLOBAL FULL JOIN t2 ON c1 = c2").from).joins, vec![join_with_constraint( "t2", None, true, JoinOperator::FullOuter )] ); } #[test] fn parse_joins_using() { fn join_with_constraint( relation: impl Into, alias: Option, f: impl Fn(JoinConstraint) -> JoinOperator, ) -> Join { Join { relation: TableFactor::Table { name: ObjectName::from(vec![Ident::new(relation.into())]), alias, args: None, with_hints: vec![], version: None, partitions: vec![], with_ordinality: false, json_path: None, sample: None, index_hints: vec![], }, global: false, join_operator: f(JoinConstraint::Using(vec![ObjectName::from(vec![ "c1".into() ])])), } } // Test parsing of aliases assert_eq!( only(&verified_only_select("SELECT * FROM t1 JOIN t2 AS foo USING(c1)").from).joins, vec![join_with_constraint( "t2", table_alias(true, "foo"), JoinOperator::Join, )] ); one_statement_parses_to( "SELECT * FROM t1 JOIN t2 AS foo USING(c1)", "SELECT * FROM t1 JOIN t2 AS foo USING(c1)", ); one_statement_parses_to( "SELECT * FROM t1 JOIN t2 foo USING(c1)", "SELECT * FROM t1 JOIN t2 foo USING(c1)", ); // Test parsing of different join operators assert_eq!( only(&verified_only_select("SELECT * FROM t1 JOIN t2 USING(c1)").from).joins, vec![join_with_constraint("t2", None, JoinOperator::Join)] ); assert_eq!( only(&verified_only_select("SELECT * FROM t1 INNER JOIN t2 USING(c1)").from).joins, vec![join_with_constraint("t2", None, JoinOperator::Inner)] ); assert_eq!( only(&verified_only_select("SELECT * FROM t1 LEFT JOIN t2 USING(c1)").from).joins, vec![join_with_constraint("t2", None, JoinOperator::Left)] ); assert_eq!( only(&verified_only_select("SELECT * FROM t1 LEFT OUTER JOIN t2 USING(c1)").from).joins, vec![join_with_constraint("t2", None, JoinOperator::LeftOuter)] ); assert_eq!( only(&verified_only_select("SELECT * FROM t1 RIGHT JOIN t2 USING(c1)").from).joins, vec![join_with_constraint("t2", None, JoinOperator::Right)] ); assert_eq!( only(&verified_only_select("SELECT * FROM t1 RIGHT OUTER JOIN t2 USING(c1)").from).joins, vec![join_with_constraint("t2", None, JoinOperator::RightOuter)] ); assert_eq!( only(&verified_only_select("SELECT * FROM t1 SEMI JOIN t2 USING(c1)").from).joins, vec![join_with_constraint("t2", None, JoinOperator::Semi)] ); assert_eq!( only(&verified_only_select("SELECT * FROM t1 LEFT SEMI JOIN t2 USING(c1)").from).joins, vec![join_with_constraint("t2", None, JoinOperator::LeftSemi)] ); assert_eq!( only(&verified_only_select("SELECT * FROM t1 RIGHT SEMI JOIN t2 USING(c1)").from).joins, vec![join_with_constraint("t2", None, JoinOperator::RightSemi)] ); assert_eq!( only(&verified_only_select("SELECT * FROM t1 ANTI JOIN t2 USING(c1)").from).joins, vec![join_with_constraint("t2", None, JoinOperator::Anti)] ); assert_eq!( only(&verified_only_select("SELECT * FROM t1 LEFT ANTI JOIN t2 USING(c1)").from).joins, vec![join_with_constraint("t2", None, JoinOperator::LeftAnti)] ); assert_eq!( only(&verified_only_select("SELECT * FROM t1 RIGHT ANTI JOIN t2 USING(c1)").from).joins, vec![join_with_constraint("t2", None, JoinOperator::RightAnti)] ); assert_eq!( only(&verified_only_select("SELECT * FROM t1 FULL JOIN t2 USING(c1)").from).joins, vec![join_with_constraint("t2", None, JoinOperator::FullOuter)] ); verified_stmt("SELECT * FROM tbl1 AS t1 JOIN tbl2 AS t2 USING(t2.col1)"); } #[test] fn parse_natural_join() { fn natural_join(f: impl Fn(JoinConstraint) -> JoinOperator, alias: Option) -> Join { Join { relation: TableFactor::Table { name: ObjectName::from(vec![Ident::new("t2")]), alias, args: None, with_hints: vec![], version: None, partitions: vec![], with_ordinality: false, json_path: None, sample: None, index_hints: vec![], }, global: false, join_operator: f(JoinConstraint::Natural), } } // unspecified join assert_eq!( only(&verified_only_select("SELECT * FROM t1 NATURAL JOIN t2").from).joins, vec![natural_join(JoinOperator::Join, None)] ); // inner join explicitly assert_eq!( only(&verified_only_select("SELECT * FROM t1 NATURAL INNER JOIN t2").from).joins, vec![natural_join(JoinOperator::Inner, None)] ); // left join explicitly assert_eq!( only(&verified_only_select("SELECT * FROM t1 NATURAL LEFT JOIN t2").from).joins, vec![natural_join(JoinOperator::Left, None)] ); // left outer join explicitly assert_eq!( only(&verified_only_select("SELECT * FROM t1 NATURAL LEFT OUTER JOIN t2").from).joins, vec![natural_join(JoinOperator::LeftOuter, None)] ); // right join explicitly assert_eq!( only(&verified_only_select("SELECT * FROM t1 NATURAL RIGHT JOIN t2").from).joins, vec![natural_join(JoinOperator::Right, None)] ); // right outer join explicitly assert_eq!( only(&verified_only_select("SELECT * FROM t1 NATURAL RIGHT OUTER JOIN t2").from).joins, vec![natural_join(JoinOperator::RightOuter, None)] ); // full join explicitly assert_eq!( only(&verified_only_select("SELECT * FROM t1 NATURAL FULL JOIN t2").from).joins, vec![natural_join(JoinOperator::FullOuter, None)] ); // natural join another table with alias assert_eq!( only(&verified_only_select("SELECT * FROM t1 NATURAL JOIN t2 AS t3").from).joins, vec![natural_join(JoinOperator::Join, table_alias(true, "t3"))] ); let sql = "SELECT * FROM t1 natural"; assert_eq!( ParserError::ParserError("Expected: a join type after NATURAL, found: EOF".to_string()), parse_sql_statements(sql).unwrap_err(), ); } #[test] fn parse_complex_join() { let sql = "SELECT c1, c2 FROM t1, t4 JOIN t2 ON t2.c = t1.c LEFT JOIN t3 USING(q, c) WHERE t4.c = t1.c"; verified_only_select(sql); } #[test] fn parse_join_nesting() { let sql = "SELECT * FROM a NATURAL JOIN (b NATURAL JOIN (c NATURAL JOIN d NATURAL JOIN e)) \ NATURAL JOIN (f NATURAL JOIN (g NATURAL JOIN h))"; assert_eq!( only(&verified_only_select(sql).from).joins, vec![ join(nest!(table("b"), nest!(table("c"), table("d"), table("e")))), join(nest!(table("f"), nest!(table("g"), table("h")))), ], ); let sql = "SELECT * FROM (a NATURAL JOIN b) NATURAL JOIN c"; let select = verified_only_select(sql); let from = only(select.from); assert_eq!(from.relation, nest!(table("a"), table("b"))); assert_eq!(from.joins, vec![join(table("c"))]); let sql = "SELECT * FROM (((a NATURAL JOIN b)))"; let select = verified_only_select(sql); let from = only(select.from); assert_eq!(from.relation, nest!(nest!(nest!(table("a"), table("b"))))); assert_eq!(from.joins, vec![]); let sql = "SELECT * FROM a NATURAL JOIN (((b NATURAL JOIN c)))"; let select = verified_only_select(sql); let from = only(select.from); assert_eq!(from.relation, table("a")); assert_eq!( from.joins, vec![join(nest!(nest!(nest!(table("b"), table("c")))))] ); let sql = "SELECT * FROM (a NATURAL JOIN b) AS c"; let select = verified_only_select(sql); let from = only(select.from); assert_eq!( from.relation, TableFactor::NestedJoin { table_with_joins: Box::new(TableWithJoins { relation: table("a"), joins: vec![join(table("b"))], }), alias: table_alias(true, "c"), } ); assert_eq!(from.joins, vec![]); } #[test] fn parse_join_syntax_variants() { verified_stmt("SELECT c1 FROM t1 JOIN t2 USING(c1)"); verified_stmt("SELECT c1 FROM t1 INNER JOIN t2 USING(c1)"); verified_stmt("SELECT c1 FROM t1 LEFT JOIN t2 USING(c1)"); verified_stmt("SELECT c1 FROM t1 LEFT OUTER JOIN t2 USING(c1)"); verified_stmt("SELECT c1 FROM t1 RIGHT JOIN t2 USING(c1)"); verified_stmt("SELECT c1 FROM t1 RIGHT OUTER JOIN t2 USING(c1)"); one_statement_parses_to( "SELECT c1 FROM t1 FULL OUTER JOIN t2 USING(c1)", "SELECT c1 FROM t1 FULL JOIN t2 USING(c1)", ); let dialects = all_dialects_except(|d| d.is_table_alias(&Keyword::OUTER, &mut Parser::new(d))); let res = dialects.parse_sql_statements("SELECT * FROM a OUTER JOIN b ON 1"); assert_eq!( ParserError::ParserError("Expected: APPLY, found: JOIN".to_string()), res.unwrap_err() ); } #[test] fn parse_ctes() { let cte_sqls = vec!["SELECT 1 AS foo", "SELECT 2 AS bar"]; let with = &format!( "WITH a AS ({}), b AS ({}) SELECT foo + bar FROM a, b", cte_sqls[0], cte_sqls[1] ); fn assert_ctes_in_select(expected: &[&str], sel: &Query) { for (i, exp) in expected.iter().enumerate() { let Cte { alias, query, .. } = &sel.with.as_ref().unwrap().cte_tables[i]; assert_eq!(*exp, query.to_string()); assert_eq!(false, alias.explicit); assert_eq!( if i == 0 { Ident::new("a") } else { Ident::new("b") }, alias.name ); assert!(alias.columns.is_empty()); } } // Top-level CTE assert_ctes_in_select(&cte_sqls, &verified_query(with)); // CTE in a subquery let sql = &format!("SELECT ({with})"); let select = verified_only_select(sql); match expr_from_projection(only(&select.projection)) { Expr::Subquery(ref subquery) => { assert_ctes_in_select(&cte_sqls, subquery.as_ref()); } _ => panic!("Expected: subquery"), } // CTE in a derived table let sql = &format!("SELECT * FROM ({with})"); let select = verified_only_select(sql); match only(select.from).relation { TableFactor::Derived { subquery, .. } => { assert_ctes_in_select(&cte_sqls, subquery.as_ref()) } _ => panic!("Expected: derived table"), } // CTE in a view let sql = &format!("CREATE VIEW v AS {with}"); match verified_stmt(sql) { Statement::CreateView(create_view) => assert_ctes_in_select(&cte_sqls, &create_view.query), _ => panic!("Expected: CREATE VIEW"), } // CTE in a CTE... let sql = &format!("WITH outer_cte AS ({with}) SELECT * FROM outer_cte"); let select = verified_query(sql); assert_ctes_in_select(&cte_sqls, &only(&select.with.unwrap().cte_tables).query); } #[test] fn parse_cte_renamed_columns() { let sql = "WITH cte (col1, col2) AS (SELECT foo, bar FROM baz) SELECT * FROM cte"; let query = all_dialects().verified_query(sql); assert_eq!( vec![ TableAliasColumnDef::from_name("col1"), TableAliasColumnDef::from_name("col2") ], query .with .unwrap() .cte_tables .first() .unwrap() .alias .columns ); } #[test] fn parse_recursive_cte() { let cte_query = "SELECT 1 UNION ALL SELECT val + 1 FROM nums WHERE val < 10".to_owned(); let sql = &format!("WITH RECURSIVE nums (val) AS ({cte_query}) SELECT * FROM nums"); let cte_query = verified_query(&cte_query); let query = verified_query(sql); let with = query.with.as_ref().unwrap(); assert!(with.recursive); assert_eq!(with.cte_tables.len(), 1); let expected = Cte { alias: TableAlias { explicit: false, name: Ident { value: "nums".to_string(), quote_style: None, span: Span::empty(), }, columns: vec![TableAliasColumnDef::from_name("val")], at: None, }, query: Box::new(cte_query), from: None, materialized: None, closing_paren_token: AttachedToken::empty(), }; assert_eq!(with.cte_tables.first().unwrap(), &expected); } #[test] fn parse_cte_in_data_modification_statements() { match verified_stmt("WITH x AS (SELECT 1) UPDATE t SET bar = (SELECT * FROM x)") { Statement::Query(query) => { assert_eq!(query.with.unwrap().to_string(), "WITH x AS (SELECT 1)"); assert!(matches!(*query.body, SetExpr::Update(_))); } other => panic!("Expected: UPDATE, got: {other:?}"), } match verified_stmt("WITH t (x) AS (SELECT 9) DELETE FROM q WHERE id IN (SELECT x FROM t)") { Statement::Query(query) => { assert_eq!(query.with.unwrap().to_string(), "WITH t (x) AS (SELECT 9)"); assert!(matches!(*query.body, SetExpr::Delete(_))); } other => panic!("Expected: DELETE, got: {other:?}"), } match verified_stmt("WITH x AS (SELECT 42) INSERT INTO t SELECT foo FROM x") { Statement::Query(query) => { assert_eq!(query.with.unwrap().to_string(), "WITH x AS (SELECT 42)"); assert!(matches!(*query.body, SetExpr::Insert(_))); } other => panic!("Expected: INSERT, got: {other:?}"), } } #[test] fn parse_derived_tables() { let sql = "SELECT a.x, b.y FROM (SELECT x FROM foo) AS a CROSS JOIN (SELECT y FROM bar) AS b"; let _ = verified_only_select(sql); //TODO: add assertions let sql = "SELECT a.x, b.y \ FROM (SELECT x FROM foo) AS a (x) \ CROSS JOIN (SELECT y FROM bar) AS b (y)"; let _ = verified_only_select(sql); //TODO: add assertions let sql = "SELECT * FROM (((SELECT 1)))"; let _ = verified_only_select(sql); // TODO: add assertions let sql = "SELECT * FROM t NATURAL JOIN (((SELECT 1)))"; let _ = verified_only_select(sql); // TODO: add assertions let sql = "SELECT * FROM (((SELECT 1) UNION (SELECT 2)) AS t1 NATURAL JOIN t2)"; let select = verified_only_select(sql); let from = only(select.from); assert_eq!( from.relation, TableFactor::NestedJoin { table_with_joins: Box::new(TableWithJoins { relation: TableFactor::Derived { lateral: false, subquery: Box::new(verified_query("(SELECT 1) UNION (SELECT 2)")), alias: table_alias(true, "t1"), sample: None, }, joins: vec![Join { relation: table_from_name(ObjectName::from(vec!["t2".into()])), global: false, join_operator: JoinOperator::Join(JoinConstraint::Natural), }], }), alias: None, } ); } #[test] fn parse_union_except_intersect_minus() { // TODO: add assertions verified_stmt("SELECT 1 UNION SELECT 2"); verified_stmt("SELECT 1 UNION ALL SELECT 2"); verified_stmt("SELECT 1 UNION DISTINCT SELECT 1"); verified_stmt("SELECT 1 EXCEPT SELECT 2"); verified_stmt("SELECT 1 EXCEPT ALL SELECT 2"); verified_stmt("SELECT 1 EXCEPT DISTINCT SELECT 1"); verified_stmt("SELECT 1 INTERSECT SELECT 2"); verified_stmt("SELECT 1 INTERSECT ALL SELECT 2"); verified_stmt("SELECT 1 INTERSECT DISTINCT SELECT 1"); verified_stmt("SELECT 1 UNION SELECT 2 UNION SELECT 3"); verified_stmt("SELECT 1 EXCEPT SELECT 2 UNION SELECT 3"); // Union[Except[1,2], 3] verified_stmt("SELECT 1 INTERSECT (SELECT 2 EXCEPT SELECT 3)"); verified_stmt("WITH cte AS (SELECT 1 AS foo) (SELECT foo FROM cte ORDER BY 1 LIMIT 1)"); verified_stmt("SELECT 1 UNION (SELECT 2 ORDER BY 1 LIMIT 1)"); verified_stmt("SELECT 1 UNION SELECT 2 INTERSECT SELECT 3"); // Union[1, Intersect[2,3]] verified_stmt("SELECT foo FROM tab UNION SELECT bar FROM TAB"); verified_stmt("(SELECT * FROM new EXCEPT SELECT * FROM old) UNION ALL (SELECT * FROM old EXCEPT SELECT * FROM new) ORDER BY 1"); verified_stmt("(SELECT * FROM new EXCEPT DISTINCT SELECT * FROM old) UNION DISTINCT (SELECT * FROM old EXCEPT DISTINCT SELECT * FROM new) ORDER BY 1"); verified_stmt("SELECT 1 AS x, 2 AS y EXCEPT BY NAME SELECT 9 AS y, 8 AS x"); verified_stmt("SELECT 1 AS x, 2 AS y EXCEPT ALL BY NAME SELECT 9 AS y, 8 AS x"); verified_stmt("SELECT 1 AS x, 2 AS y EXCEPT DISTINCT BY NAME SELECT 9 AS y, 8 AS x"); verified_stmt("SELECT 1 AS x, 2 AS y INTERSECT BY NAME SELECT 9 AS y, 8 AS x"); verified_stmt("SELECT 1 AS x, 2 AS y INTERSECT ALL BY NAME SELECT 9 AS y, 8 AS x"); verified_stmt("SELECT 1 AS x, 2 AS y INTERSECT DISTINCT BY NAME SELECT 9 AS y, 8 AS x"); // Dialects that support `MINUS` as column identifier // do not support `MINUS` as a set operator. let dialects = all_dialects_where(|d| !d.is_column_alias(&Keyword::MINUS, &mut Parser::new(d))); dialects.verified_stmt("SELECT 1 MINUS SELECT 2"); dialects.verified_stmt("SELECT 1 MINUS ALL SELECT 2"); dialects.verified_stmt("SELECT 1 MINUS DISTINCT SELECT 1"); } #[test] fn parse_values() { verified_stmt("SELECT * FROM (VALUES (1), (2), (3))"); verified_stmt("SELECT * FROM (VALUES (1), (2), (3)), (VALUES (1, 2, 3))"); verified_stmt("SELECT * FROM (VALUES (1)) UNION VALUES (1)"); verified_stmt("SELECT * FROM (VALUES ROW(1, NULL, 'a'), ROW(2, NULL, 'b')) AS t (a, b, c)"); } #[test] fn parse_multiple_statements() { fn test_with(sql1: &str, sql2_kw: &str, sql2_rest: &str) { // Check that a string consisting of two statements delimited by a semicolon // parses the same as both statements individually: let res = parse_sql_statements(&(sql1.to_owned() + ";" + sql2_kw + sql2_rest)); assert_eq!( vec![ one_statement_parses_to(sql1, ""), one_statement_parses_to(&(sql2_kw.to_owned() + sql2_rest), ""), ], res.unwrap() ); // Check that extra semicolon at the end is stripped by normalization: one_statement_parses_to(&(sql1.to_owned() + ";"), sql1); // Check that forgetting the semicolon results in an error: let res = parse_sql_statements(&(sql1.to_owned() + " " + sql2_kw + sql2_rest)); assert_eq!( ParserError::ParserError("Expected: end of statement, found: ".to_string() + sql2_kw), res.unwrap_err() ); } test_with("SELECT foo", "SELECT", " bar"); // ensure that SELECT/WITH is not parsed as a table or column alias if ';' // separating the statements is omitted: test_with("SELECT foo FROM baz", "SELECT", " bar"); test_with("SELECT foo", "WITH", " cte AS (SELECT 1 AS s) SELECT bar"); test_with( "SELECT foo FROM baz", "WITH", " cte AS (SELECT 1 AS s) SELECT bar", ); test_with("DELETE FROM foo", "SELECT", " bar"); test_with("INSERT INTO foo VALUES (1)", "SELECT", " bar"); // Since MySQL supports the `CREATE TABLE SELECT` syntax, this needs to be handled separately let res = parse_sql_statements("CREATE TABLE foo (baz INT); SELECT bar"); assert_eq!( vec![ one_statement_parses_to("CREATE TABLE foo (baz INT)", ""), one_statement_parses_to("SELECT bar", ""), ], res.unwrap() ); // Check that extra semicolon at the end is stripped by normalization: one_statement_parses_to("CREATE TABLE foo (baz INT);", "CREATE TABLE foo (baz INT)"); // Make sure that empty statements do not cause an error: let res = parse_sql_statements(";;"); assert_eq!(0, res.unwrap().len()); } #[test] fn parse_scalar_subqueries() { let sql = "(SELECT 1) + (SELECT 2)"; assert_matches!( verified_expr(sql), Expr::BinaryOp { op: BinaryOperator::Plus, .. } ); } #[test] fn parse_substring() { verified_stmt("SELECT SUBSTRING('1')"); verified_stmt("SELECT SUBSTRING('1' FROM 1)"); verified_stmt("SELECT SUBSTRING('1' FROM 1 FOR 3)"); verified_stmt("SELECT SUBSTRING('1', 1, 3)"); verified_stmt("SELECT SUBSTRING('1', 1)"); verified_stmt("SELECT SUBSTRING('1' FOR 3)"); verified_stmt("SELECT SUBSTRING('foo' FROM 1 FOR 2) FROM t"); verified_stmt("SELECT SUBSTR('foo' FROM 1 FOR 2) FROM t"); verified_stmt("SELECT SUBSTR('foo', 1, 2) FROM t"); } #[test] fn parse_overlay() { one_statement_parses_to( "SELECT OVERLAY('abccccde' PLACING 'abc' FROM 3)", "SELECT OVERLAY('abccccde' PLACING 'abc' FROM 3)", ); one_statement_parses_to( "SELECT OVERLAY('abccccde' PLACING 'abc' FROM 3 FOR 12)", "SELECT OVERLAY('abccccde' PLACING 'abc' FROM 3 FOR 12)", ); assert_eq!( ParserError::ParserError("Expected: PLACING, found: FROM".to_owned()), parse_sql_statements("SELECT OVERLAY('abccccde' FROM 3)").unwrap_err(), ); let sql = "SELECT OVERLAY('abcdef' PLACING name FROM 3 FOR id + 1) FROM CUSTOMERS"; let select = verified_only_select(sql); assert_eq!( &Expr::Overlay { expr: Box::new(Expr::Value( (Value::SingleQuotedString("abcdef".to_string())).with_empty_span() )), overlay_what: Box::new(Expr::Identifier(Ident::new("name"))), overlay_from: Box::new(Expr::value(number("3"))), overlay_for: Some(Box::new(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("id"))), op: BinaryOperator::Plus, right: Box::new(Expr::value(number("1"))), })), }, expr_from_projection(only(&select.projection)) ); } #[test] fn parse_trim() { one_statement_parses_to( "SELECT TRIM(BOTH 'xyz' FROM 'xyzfooxyz')", "SELECT TRIM(BOTH 'xyz' FROM 'xyzfooxyz')", ); one_statement_parses_to( "SELECT TRIM(LEADING 'xyz' FROM 'xyzfooxyz')", "SELECT TRIM(LEADING 'xyz' FROM 'xyzfooxyz')", ); one_statement_parses_to( "SELECT TRIM(TRAILING 'xyz' FROM 'xyzfooxyz')", "SELECT TRIM(TRAILING 'xyz' FROM 'xyzfooxyz')", ); one_statement_parses_to( "SELECT TRIM('xyz' FROM 'xyzfooxyz')", "SELECT TRIM('xyz' FROM 'xyzfooxyz')", ); one_statement_parses_to("SELECT TRIM(' foo ')", "SELECT TRIM(' foo ')"); one_statement_parses_to( "SELECT TRIM(LEADING ' foo ')", "SELECT TRIM(LEADING ' foo ')", ); assert_eq!( ParserError::ParserError("Expected: ), found: 'xyz'".to_owned()), parse_sql_statements("SELECT TRIM(FOO 'xyz' FROM 'xyzfooxyz')").unwrap_err() ); // dialects that support comma-separated TRIM syntax let dialects = all_dialects_where(|d| d.supports_comma_separated_trim()); let sql = "SELECT TRIM(' xyz ', ' ')"; let select = dialects.verified_only_select(sql); 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(" ".to_owned()).with_empty_span() )]), }, expr_from_projection(only(&select.projection)) ); let sql = "SELECT TRIM('xyz', 'a')"; let select = dialects.verified_only_select(sql); 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)) ); // dialects without comma-style TRIM syntax should fail let unsupported_dialects = all_dialects_where(|d| !d.supports_comma_separated_trim()); assert_eq!( ParserError::ParserError("Expected: ), found: ,".to_owned()), unsupported_dialects .parse_sql_statements("SELECT TRIM('xyz', 'a')") .unwrap_err() ); } #[test] fn parse_exists_subquery() { let expected_inner = verified_query("SELECT 1"); let sql = "SELECT * FROM t WHERE EXISTS (SELECT 1)"; let select = verified_only_select(sql); assert_eq!( Expr::Exists { negated: false, subquery: Box::new(expected_inner.clone()), }, select.selection.unwrap(), ); let sql = "SELECT * FROM t WHERE NOT EXISTS (SELECT 1)"; let select = verified_only_select(sql); assert_eq!( Expr::Exists { negated: true, subquery: Box::new(expected_inner), }, select.selection.unwrap(), ); verified_stmt("SELECT * FROM t WHERE EXISTS (WITH u AS (SELECT 1) SELECT * FROM u)"); verified_stmt("SELECT EXISTS (SELECT 1)"); let res = all_dialects_except(|d| d.is::()) .parse_sql_statements("SELECT EXISTS ("); assert_eq!( ParserError::ParserError( "Expected: SELECT, VALUES, or a subquery in the query body, found: EOF".to_string() ), res.unwrap_err(), ); let res = all_dialects_except(|d| d.is::()) .parse_sql_statements("SELECT EXISTS (NULL)"); assert_eq!( ParserError::ParserError( "Expected: SELECT, VALUES, or a subquery in the query body, found: NULL".to_string() ), res.unwrap_err(), ); } #[test] fn parse_create_database() { let sql = "CREATE DATABASE mydb"; match verified_stmt(sql) { Statement::CreateDatabase { db_name, if_not_exists, location, managed_location, clone, .. } => { assert_eq!("mydb", db_name.to_string()); assert!(!if_not_exists); assert_eq!(None, location); assert_eq!(None, managed_location); assert_eq!(None, clone); } _ => unreachable!(), } let sql = "CREATE DATABASE mydb CLONE otherdb"; match verified_stmt(sql) { Statement::CreateDatabase { db_name, if_not_exists, location, managed_location, clone, .. } => { assert_eq!("mydb", db_name.to_string()); assert!(!if_not_exists); assert_eq!(None, location); assert_eq!(None, managed_location); assert_eq!( Some(ObjectName::from(vec![Ident::new("otherdb".to_string())])), clone ); } _ => unreachable!(), } } #[test] fn parse_create_database_ine() { let sql = "CREATE DATABASE IF NOT EXISTS mydb"; match verified_stmt(sql) { Statement::CreateDatabase { db_name, if_not_exists, location, managed_location, clone, .. } => { assert_eq!("mydb", db_name.to_string()); assert!(if_not_exists); assert_eq!(None, location); assert_eq!(None, managed_location); assert_eq!(None, clone); } _ => unreachable!(), } } #[test] fn parse_drop_database() { let sql = "DROP DATABASE mycatalog.mydb"; match verified_stmt(sql) { Statement::Drop { names, object_type, if_exists, .. } => { assert_eq!( vec!["mycatalog.mydb"], names.iter().map(ToString::to_string).collect::>() ); assert_eq!(ObjectType::Database, object_type); assert!(!if_exists); } _ => unreachable!(), } } #[test] fn parse_drop_database_if_exists() { let sql = "DROP DATABASE IF EXISTS mydb"; match verified_stmt(sql) { Statement::Drop { object_type, if_exists, .. } => { assert_eq!(ObjectType::Database, object_type); assert!(if_exists); } _ => unreachable!(), } } #[test] fn parse_create_view() { let sql = "CREATE VIEW myschema.myview AS SELECT foo FROM bar"; match verified_stmt(sql) { Statement::CreateView(CreateView { or_alter, name, columns, query, or_replace, materialized, options, cluster_by, comment, with_no_schema_binding: late_binding, if_not_exists, temporary, to, params, name_before_not_exists: _, secure: _, copy_grants: _, }) => { assert_eq!(or_alter, false); assert_eq!("myschema.myview", name.to_string()); assert_eq!(Vec::::new(), columns); assert_eq!("SELECT foo FROM bar", query.to_string()); assert!(!materialized); assert!(!or_replace); assert_eq!(options, CreateTableOptions::None); assert_eq!(cluster_by, vec![]); assert!(comment.is_none()); assert!(!late_binding); assert!(!if_not_exists); assert!(!temporary); assert!(to.is_none()); assert!(params.is_none()); } _ => unreachable!(), } let _ = verified_stmt("CREATE OR ALTER VIEW v AS SELECT 1"); } #[test] fn parse_create_view_with_options() { let sql = "CREATE VIEW v WITH (foo = 'bar', a = 123) AS SELECT 1"; match verified_stmt(sql) { Statement::CreateView(create_view) => { assert_eq!( CreateTableOptions::With(vec![ SqlOption::KeyValue { key: "foo".into(), value: Expr::Value( (Value::SingleQuotedString("bar".into())).with_empty_span() ), }, SqlOption::KeyValue { key: "a".into(), value: Expr::value(number("123")), }, ]), create_view.options ); } _ => unreachable!(), } } #[test] fn parse_create_view_with_columns() { let sql = "CREATE VIEW v (has, cols) AS SELECT 1, 2"; // TODO: why does this fail for ClickHouseDialect? (#1449) // match all_dialects().verified_stmt(sql) { match all_dialects_except(|d| d.is::()).verified_stmt(sql) { Statement::CreateView(create_view) => { let or_alter = create_view.or_alter; let name = create_view.name; let columns = create_view.columns; let or_replace = create_view.or_replace; let options = create_view.options; let query = create_view.query; let materialized = create_view.materialized; let cluster_by = create_view.cluster_by; let comment = create_view.comment; let late_binding = create_view.with_no_schema_binding; let if_not_exists = create_view.if_not_exists; let temporary = create_view.temporary; let to = create_view.to; let params = create_view.params; assert_eq!(or_alter, false); assert_eq!("v", name.to_string()); assert_eq!( columns, vec![Ident::new("has"), Ident::new("cols"),] .into_iter() .map(|name| ViewColumnDef { name, data_type: None, options: None, }) .collect::>() ); assert_eq!(options, CreateTableOptions::None); assert_eq!("SELECT 1, 2", query.to_string()); assert!(!materialized); assert!(!or_replace); assert_eq!(cluster_by, vec![]); assert!(comment.is_none()); assert!(!late_binding); assert!(!if_not_exists); assert!(!temporary); assert!(to.is_none()); assert!(params.is_none()); } _ => unreachable!(), } } #[test] fn parse_create_view_temporary() { let sql = "CREATE TEMPORARY VIEW myschema.myview AS SELECT foo FROM bar"; match verified_stmt(sql) { Statement::CreateView(CreateView { or_alter, name, columns, query, or_replace, materialized, options, cluster_by, comment, with_no_schema_binding: late_binding, if_not_exists, temporary, to, params, name_before_not_exists: _, secure: _, copy_grants: _, }) => { assert_eq!(or_alter, false); assert_eq!("myschema.myview", name.to_string()); assert_eq!(Vec::::new(), columns); assert_eq!("SELECT foo FROM bar", query.to_string()); assert!(!materialized); assert!(!or_replace); assert_eq!(options, CreateTableOptions::None); assert_eq!(cluster_by, vec![]); assert!(comment.is_none()); assert!(!late_binding); assert!(!if_not_exists); assert!(temporary); assert!(to.is_none()); assert!(params.is_none()); } _ => unreachable!(), } } #[test] fn parse_create_or_replace_view() { let sql = "CREATE OR REPLACE VIEW v AS SELECT 1"; match verified_stmt(sql) { Statement::CreateView(CreateView { or_alter, name, columns, or_replace, options, query, materialized, cluster_by, comment, with_no_schema_binding: late_binding, if_not_exists, temporary, to, params, name_before_not_exists: _, secure: _, copy_grants: _, }) => { assert_eq!(or_alter, false); assert_eq!("v", name.to_string()); assert_eq!(columns, vec![]); assert_eq!(options, CreateTableOptions::None); assert_eq!("SELECT 1", query.to_string()); assert!(!materialized); assert!(or_replace); assert_eq!(cluster_by, vec![]); assert!(comment.is_none()); assert!(!late_binding); assert!(!if_not_exists); assert!(!temporary); assert!(to.is_none()); assert!(params.is_none()); } _ => unreachable!(), } } #[test] fn parse_create_or_replace_materialized_view() { // Supported in BigQuery (Beta) // https://cloud.google.com/bigquery/docs/materialized-views-intro // and Snowflake: // https://docs.snowflake.com/en/sql-reference/sql/create-materialized-view.html let sql = "CREATE OR REPLACE MATERIALIZED VIEW v AS SELECT 1"; match verified_stmt(sql) { Statement::CreateView(CreateView { or_alter, name, columns, or_replace, options, query, materialized, cluster_by, comment, with_no_schema_binding: late_binding, if_not_exists, temporary, to, params, name_before_not_exists: _, secure: _, copy_grants: _, }) => { assert_eq!(or_alter, false); assert_eq!("v", name.to_string()); assert_eq!(columns, vec![]); assert_eq!(options, CreateTableOptions::None); assert_eq!("SELECT 1", query.to_string()); assert!(materialized); assert!(or_replace); assert_eq!(cluster_by, vec![]); assert!(comment.is_none()); assert!(!late_binding); assert!(!if_not_exists); assert!(!temporary); assert!(to.is_none()); assert!(params.is_none()); } _ => unreachable!(), } } #[test] fn parse_create_materialized_view() { let sql = "CREATE MATERIALIZED VIEW myschema.myview AS SELECT foo FROM bar"; match verified_stmt(sql) { Statement::CreateView(CreateView { or_alter, name, or_replace, columns, query, materialized, options, cluster_by, comment, with_no_schema_binding: late_binding, if_not_exists, temporary, to, params, name_before_not_exists: _, secure: _, copy_grants: _, }) => { assert_eq!(or_alter, false); assert_eq!("myschema.myview", name.to_string()); assert_eq!(Vec::::new(), columns); assert_eq!("SELECT foo FROM bar", query.to_string()); assert!(materialized); assert_eq!(options, CreateTableOptions::None); assert!(!or_replace); assert_eq!(cluster_by, vec![]); assert!(comment.is_none()); assert!(!late_binding); assert!(!if_not_exists); assert!(!temporary); assert!(to.is_none()); assert!(params.is_none()); } _ => unreachable!(), } } #[test] fn parse_create_materialized_view_with_cluster_by() { let sql = "CREATE MATERIALIZED VIEW myschema.myview CLUSTER BY (foo) AS SELECT foo FROM bar"; match verified_stmt(sql) { Statement::CreateView(CreateView { or_alter, name, or_replace, columns, query, materialized, options, cluster_by, comment, with_no_schema_binding: late_binding, if_not_exists, temporary, to, params, name_before_not_exists: _, secure: _, copy_grants: _, }) => { assert_eq!(or_alter, false); assert_eq!("myschema.myview", name.to_string()); assert_eq!(Vec::::new(), columns); assert_eq!("SELECT foo FROM bar", query.to_string()); assert!(materialized); assert_eq!(options, CreateTableOptions::None); assert!(!or_replace); assert_eq!(cluster_by, vec![Ident::new("foo")]); assert!(comment.is_none()); assert!(!late_binding); assert!(!if_not_exists); assert!(!temporary); assert!(to.is_none()); assert!(params.is_none()); } _ => unreachable!(), } } #[test] fn parse_drop_table() { let sql = "DROP TABLE foo"; match verified_stmt(sql) { Statement::Drop { object_type, if_exists, names, cascade, purge: _, temporary, .. } => { assert!(!if_exists); assert_eq!(ObjectType::Table, object_type); assert_eq!( vec!["foo"], names.iter().map(ToString::to_string).collect::>() ); assert!(!cascade); assert!(!temporary); } _ => unreachable!(), } let sql = "DROP TABLE IF EXISTS foo, bar CASCADE"; match verified_stmt(sql) { Statement::Drop { object_type, if_exists, names, cascade, purge: _, temporary, .. } => { assert!(if_exists); assert_eq!(ObjectType::Table, object_type); assert_eq!( vec!["foo", "bar"], names.iter().map(ToString::to_string).collect::>() ); assert!(cascade); assert!(!temporary); } _ => unreachable!(), } let sql = "DROP TABLE"; assert_eq!( ParserError::ParserError("Expected: identifier, found: EOF".to_string()), parse_sql_statements(sql).unwrap_err(), ); let sql = "DROP TABLE IF EXISTS foo, bar CASCADE RESTRICT"; assert_eq!( ParserError::ParserError("Cannot specify both CASCADE and RESTRICT in DROP".to_string()), parse_sql_statements(sql).unwrap_err(), ); } #[test] fn parse_drop_view() { let sql = "DROP VIEW myschema.myview"; match verified_stmt(sql) { Statement::Drop { names, object_type, .. } => { assert_eq!( vec!["myschema.myview"], names.iter().map(ToString::to_string).collect::>() ); assert_eq!(ObjectType::View, object_type); } _ => unreachable!(), } verified_stmt("DROP MATERIALIZED VIEW a.b.c"); verified_stmt("DROP MATERIALIZED VIEW IF EXISTS a.b.c"); } #[test] fn parse_drop_user() { let sql = "DROP USER u1"; match verified_stmt(sql) { Statement::Drop { names, object_type, .. } => { assert_eq!( vec!["u1"], names.iter().map(ToString::to_string).collect::>() ); assert_eq!(ObjectType::User, object_type); } _ => unreachable!(), } verified_stmt("DROP USER IF EXISTS u1"); } #[test] fn parse_invalid_subquery_without_parens() { let res = parse_sql_statements("SELECT SELECT 1 FROM bar WHERE 1=1 FROM baz"); assert_eq!( ParserError::ParserError("Expected: end of statement, found: 1".to_string()), res.unwrap_err() ); } #[test] fn parse_offset() { // Dialects that support `OFFSET` as column identifiers // don't support this syntax. let dialects = all_dialects_where(|d| !d.is_column_alias(&Keyword::OFFSET, &mut Parser::new(d))); let expected_limit_clause = &Some(LimitClause::LimitOffset { limit: None, offset: Some(Offset { value: Expr::value(number("2")), rows: OffsetRows::Rows, }), limit_by: vec![], }); let ast = dialects.verified_query("SELECT foo FROM bar OFFSET 2 ROWS"); assert_eq!(&ast.limit_clause, expected_limit_clause); let ast = dialects.verified_query("SELECT foo FROM bar WHERE foo = 4 OFFSET 2 ROWS"); assert_eq!(&ast.limit_clause, expected_limit_clause); let ast = dialects.verified_query("SELECT foo FROM bar ORDER BY baz OFFSET 2 ROWS"); assert_eq!(&ast.limit_clause, expected_limit_clause); let ast = dialects.verified_query("SELECT foo FROM bar WHERE foo = 4 ORDER BY baz OFFSET 2 ROWS"); assert_eq!(&ast.limit_clause, expected_limit_clause); let ast = dialects.verified_query("SELECT foo FROM (SELECT * FROM bar OFFSET 2 ROWS) OFFSET 2 ROWS"); assert_eq!(&ast.limit_clause, expected_limit_clause); match *ast.body { SetExpr::Select(s) => match only(s.from).relation { TableFactor::Derived { subquery, .. } => { assert_eq!(&subquery.limit_clause, expected_limit_clause); } _ => panic!("Test broke"), }, _ => panic!("Test broke"), } let expected_limit_clause = LimitClause::LimitOffset { limit: None, offset: Some(Offset { value: Expr::value(number("0")), rows: OffsetRows::Rows, }), limit_by: vec![], }; let ast = dialects.verified_query("SELECT 'foo' OFFSET 0 ROWS"); assert_eq!(ast.limit_clause, Some(expected_limit_clause)); let expected_limit_clause = LimitClause::LimitOffset { limit: None, offset: Some(Offset { value: Expr::value(number("1")), rows: OffsetRows::Row, }), limit_by: vec![], }; let ast = dialects.verified_query("SELECT 'foo' OFFSET 1 ROW"); assert_eq!(ast.limit_clause, Some(expected_limit_clause)); let expected_limit_clause = LimitClause::LimitOffset { limit: None, offset: Some(Offset { value: Expr::value(number("2")), rows: OffsetRows::None, }), limit_by: vec![], }; let ast = dialects.verified_query("SELECT 'foo' OFFSET 2"); assert_eq!(ast.limit_clause, Some(expected_limit_clause)); } #[test] fn parse_fetch() { let fetch_first_two_rows_only = Some(Fetch { with_ties: false, percent: false, quantity: Some(Expr::value(number("2"))), }); let ast = verified_query("SELECT foo FROM bar FETCH FIRST 2 ROWS ONLY"); assert_eq!(ast.fetch, fetch_first_two_rows_only); let ast = verified_query("SELECT 'foo' FETCH FIRST 2 ROWS ONLY"); assert_eq!(ast.fetch, fetch_first_two_rows_only); let ast = verified_query("SELECT foo FROM bar FETCH FIRST ROWS ONLY"); assert_eq!( ast.fetch, Some(Fetch { with_ties: false, percent: false, quantity: None, }) ); let ast = verified_query("SELECT foo FROM bar WHERE foo = 4 FETCH FIRST 2 ROWS ONLY"); assert_eq!(ast.fetch, fetch_first_two_rows_only); let ast = verified_query("SELECT foo FROM bar ORDER BY baz FETCH FIRST 2 ROWS ONLY"); assert_eq!(ast.fetch, fetch_first_two_rows_only); let ast = verified_query( "SELECT foo FROM bar WHERE foo = 4 ORDER BY baz FETCH FIRST 2 ROWS WITH TIES", ); assert_eq!( ast.fetch, Some(Fetch { with_ties: true, percent: false, quantity: Some(Expr::value(number("2"))), }) ); let ast = verified_query("SELECT foo FROM bar FETCH FIRST 50 PERCENT ROWS ONLY"); assert_eq!( ast.fetch, Some(Fetch { with_ties: false, percent: true, quantity: Some(Expr::value(number("50"))), }) ); let ast = verified_query( "SELECT foo FROM bar WHERE foo = 4 ORDER BY baz OFFSET 2 ROWS FETCH FIRST 2 ROWS ONLY", ); let expected_limit_clause = Some(LimitClause::LimitOffset { limit: None, offset: Some(Offset { value: Expr::value(number("2")), rows: OffsetRows::Rows, }), limit_by: vec![], }); assert_eq!(ast.limit_clause, expected_limit_clause); assert_eq!(ast.fetch, fetch_first_two_rows_only); let ast = verified_query( "SELECT foo FROM (SELECT * FROM bar FETCH FIRST 2 ROWS ONLY) FETCH FIRST 2 ROWS ONLY", ); assert_eq!(ast.fetch, fetch_first_two_rows_only); match *ast.body { SetExpr::Select(s) => match only(s.from).relation { TableFactor::Derived { subquery, .. } => { assert_eq!(subquery.fetch, fetch_first_two_rows_only); } _ => panic!("Test broke"), }, _ => panic!("Test broke"), } let ast = verified_query("SELECT foo FROM (SELECT * FROM bar OFFSET 2 ROWS FETCH FIRST 2 ROWS ONLY) OFFSET 2 ROWS FETCH FIRST 2 ROWS ONLY"); let expected_limit_clause = &Some(LimitClause::LimitOffset { limit: None, offset: Some(Offset { value: Expr::value(number("2")), rows: OffsetRows::Rows, }), limit_by: vec![], }); assert_eq!(&ast.limit_clause, expected_limit_clause); assert_eq!(ast.fetch, fetch_first_two_rows_only); match *ast.body { SetExpr::Select(s) => match only(s.from).relation { TableFactor::Derived { subquery, .. } => { assert_eq!(&subquery.limit_clause, expected_limit_clause); assert_eq!(subquery.fetch, fetch_first_two_rows_only); } _ => panic!("Test broke"), }, _ => panic!("Test broke"), } } #[test] fn parse_fetch_variations() { one_statement_parses_to( "SELECT foo FROM bar FETCH FIRST 10 ROW ONLY", "SELECT foo FROM bar FETCH FIRST 10 ROWS ONLY", ); one_statement_parses_to( "SELECT foo FROM bar FETCH NEXT 10 ROW ONLY", "SELECT foo FROM bar FETCH FIRST 10 ROWS ONLY", ); one_statement_parses_to( "SELECT foo FROM bar FETCH NEXT 10 ROWS WITH TIES", "SELECT foo FROM bar FETCH FIRST 10 ROWS WITH TIES", ); one_statement_parses_to( "SELECT foo FROM bar FETCH NEXT ROWS WITH TIES", "SELECT foo FROM bar FETCH FIRST ROWS WITH TIES", ); one_statement_parses_to( "SELECT foo FROM bar FETCH FIRST ROWS ONLY", "SELECT foo FROM bar FETCH FIRST ROWS ONLY", ); } #[test] fn lateral_derived() { fn chk(lateral_in: bool) { let lateral_str = if lateral_in { "LATERAL " } else { "" }; let sql = format!( "SELECT * FROM customer LEFT JOIN {lateral_str}\ (SELECT * FROM orders WHERE orders.customer = customer.id LIMIT 3) AS orders ON 1" ); let select = verified_only_select(&sql); let from = only(select.from); assert_eq!(from.joins.len(), 1); let join = &from.joins[0]; assert_eq!( join.join_operator, JoinOperator::Left(JoinConstraint::On(Expr::Value( (test_utils::number("1")).with_empty_span() ))) ); if let TableFactor::Derived { lateral, ref subquery, alias: Some(ref alias), sample: _, } = join.relation { assert_eq!(lateral_in, lateral); assert_eq!(Ident::new("orders"), alias.name); assert_eq!( subquery.to_string(), "SELECT * FROM orders WHERE orders.customer = customer.id LIMIT 3" ); } else { unreachable!() } } chk(false); chk(true); let sql = "SELECT * FROM LATERAL UNNEST ([10,20,30]) as numbers WITH OFFSET;"; let res = parse_sql_statements(sql); assert_eq!( ParserError::ParserError("Expected: end of statement, found: WITH".to_string()), res.unwrap_err() ); let sql = "SELECT * FROM a LEFT JOIN LATERAL (b CROSS JOIN c)"; let res = parse_sql_statements(sql); assert_eq!( ParserError::ParserError( "Expected: SELECT, VALUES, or a subquery in the query body, found: b".to_string() ), res.unwrap_err() ); } #[test] fn lateral_function() { let sql = "SELECT * FROM customer LEFT JOIN LATERAL generate_series(1, customer.id)"; let actual_select_only = verified_only_select(sql); let expected = Select { select_token: AttachedToken::empty(), optimizer_hints: vec![], distinct: None, select_modifiers: None, top: None, projection: vec![SelectItem::Wildcard(WildcardAdditionalOptions::default())], exclude: None, top_before_distinct: false, into: None, from: vec![TableWithJoins { relation: table_from_name(ObjectName::from(vec![Ident { value: "customer".to_string(), quote_style: None, span: Span::empty(), }])), joins: vec![Join { relation: TableFactor::Function { lateral: true, name: ObjectName::from(vec!["generate_series".into()]), args: vec![ FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::Value( (number("1")).with_empty_span(), ))), FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::CompoundIdentifier( vec![Ident::new("customer"), Ident::new("id")], ))), ], with_ordinality: false, alias: None, }, global: false, join_operator: JoinOperator::Left(JoinConstraint::None), }], }], lateral_views: vec![], prewhere: None, selection: None, group_by: GroupByExpr::Expressions(vec![], vec![]), cluster_by: vec![], distribute_by: vec![], sort_by: vec![], having: None, named_window: vec![], qualify: None, window_before_qualify: false, value_table_mode: None, connect_by: vec![], flavor: SelectFlavor::Standard, }; assert_eq!(actual_select_only, expected); } #[test] fn parse_start_transaction() { let dialects = all_dialects_except(|d| // BigQuery and Snowflake does not support this syntax // // BigQuery: // Snowflake: d.is::() || d.is::()); match dialects .verified_stmt("START TRANSACTION READ ONLY, READ WRITE, ISOLATION LEVEL SERIALIZABLE") { Statement::StartTransaction { modes, .. } => assert_eq!( modes, vec![ TransactionMode::AccessMode(TransactionAccessMode::ReadOnly), TransactionMode::AccessMode(TransactionAccessMode::ReadWrite), TransactionMode::IsolationLevel(TransactionIsolationLevel::Serializable), ] ), _ => unreachable!(), } // For historical reasons, PostgreSQL allows the commas between the modes to // be omitted. match dialects.one_statement_parses_to( "START TRANSACTION READ ONLY READ WRITE ISOLATION LEVEL SERIALIZABLE", "START TRANSACTION READ ONLY, READ WRITE, ISOLATION LEVEL SERIALIZABLE", ) { Statement::StartTransaction { modes, .. } => assert_eq!( modes, vec![ TransactionMode::AccessMode(TransactionAccessMode::ReadOnly), TransactionMode::AccessMode(TransactionAccessMode::ReadWrite), TransactionMode::IsolationLevel(TransactionIsolationLevel::Serializable), ] ), _ => unreachable!(), } dialects.verified_stmt("START TRANSACTION"); dialects.verified_stmt("BEGIN"); dialects.verified_stmt("BEGIN WORK"); dialects.verified_stmt("BEGIN TRANSACTION"); dialects.verified_stmt("START TRANSACTION ISOLATION LEVEL READ UNCOMMITTED"); dialects.verified_stmt("START TRANSACTION ISOLATION LEVEL READ COMMITTED"); dialects.verified_stmt("START TRANSACTION ISOLATION LEVEL REPEATABLE READ"); dialects.verified_stmt("START TRANSACTION ISOLATION LEVEL SERIALIZABLE"); // Regression test for https://github.com/sqlparser-rs/sqlparser-rs/pull/139, // in which START TRANSACTION would fail to parse if followed by a statement // terminator. assert_eq!( dialects.parse_sql_statements("START TRANSACTION; SELECT 1"), Ok(vec![ verified_stmt("START TRANSACTION"), verified_stmt("SELECT 1"), ]) ); let res = dialects.parse_sql_statements("START TRANSACTION ISOLATION LEVEL BAD"); assert_eq!( ParserError::ParserError("Expected: isolation level, found: BAD".to_string()), res.unwrap_err() ); let res = dialects.parse_sql_statements("START TRANSACTION BAD"); assert_eq!( ParserError::ParserError("Expected: end of statement, found: BAD".to_string()), res.unwrap_err() ); let res = dialects.parse_sql_statements("START TRANSACTION READ ONLY,"); assert_eq!( ParserError::ParserError("Expected: transaction mode, found: EOF".to_string()), res.unwrap_err() ); // MS-SQL syntax let dialects = all_dialects_where(|d| d.supports_start_transaction_modifier()); dialects.verified_stmt("BEGIN TRY"); dialects.verified_stmt("BEGIN CATCH"); let dialects = all_dialects_where(|d| { d.supports_start_transaction_modifier() && d.supports_end_transaction_modifier() }); dialects .parse_sql_statements( r#" BEGIN TRY; SELECT 1/0; END TRY; BEGIN CATCH; EXECUTE foo; END CATCH; "#, ) .unwrap(); } #[test] fn parse_set_transaction() { // SET TRANSACTION shares transaction mode parsing code with START // TRANSACTION, so no need to duplicate the tests here. We just do a quick // sanity check. match verified_stmt("SET TRANSACTION READ ONLY, READ WRITE, ISOLATION LEVEL SERIALIZABLE") { Statement::Set(Set::SetTransaction { modes, session, snapshot, }) => { assert_eq!( modes, vec![ TransactionMode::AccessMode(TransactionAccessMode::ReadOnly), TransactionMode::AccessMode(TransactionAccessMode::ReadWrite), TransactionMode::IsolationLevel(TransactionIsolationLevel::Serializable), ] ); assert!(!session); assert_eq!(snapshot, None); } _ => unreachable!(), } } #[test] fn parse_set_variable() { match verified_stmt("SET SOMETHING = '1'") { Statement::Set(Set::SingleAssignment { scope, hivevar, variable, values, }) => { assert_eq!(scope, None); assert!(!hivevar); assert_eq!(variable, ObjectName::from(vec!["SOMETHING".into()])); assert_eq!( values, vec![Expr::Value( (Value::SingleQuotedString("1".into())).with_empty_span() )] ); } _ => unreachable!(), } match verified_stmt("SET GLOBAL VARIABLE = 'Value'") { Statement::Set(Set::SingleAssignment { scope, hivevar, variable, values, }) => { assert_eq!(scope, Some(ContextModifier::Global)); assert!(!hivevar); assert_eq!(variable, ObjectName::from(vec!["VARIABLE".into()])); assert_eq!( values, vec![Expr::Value( (Value::SingleQuotedString("Value".into())).with_empty_span() )] ); } _ => unreachable!(), } let multi_variable_dialects = all_dialects_where(|d| d.supports_parenthesized_set_variables()); let sql = r#"SET (a, b, c) = (1, 2, 3)"#; match multi_variable_dialects.verified_stmt(sql) { Statement::Set(Set::ParenthesizedAssignments { variables, values }) => { assert_eq!( variables, vec![ ObjectName::from(vec!["a".into()]), ObjectName::from(vec!["b".into()]), ObjectName::from(vec!["c".into()]), ] ); assert_eq!( values, vec![ Expr::value(number("1")), Expr::value(number("2")), Expr::value(number("3")), ] ); } _ => unreachable!(), } // Subquery expression for (sql, canonical) in [ ( "SET (a) = (SELECT 22 FROM tbl1)", "SET (a) = ((SELECT 22 FROM tbl1))", ), ( "SET (a) = (SELECT 22 FROM tbl1, (SELECT 1 FROM tbl2))", "SET (a) = ((SELECT 22 FROM tbl1, (SELECT 1 FROM tbl2)))", ), ( "SET (a) = ((SELECT 22 FROM tbl1, (SELECT 1 FROM tbl2)))", "SET (a) = ((SELECT 22 FROM tbl1, (SELECT 1 FROM tbl2)))", ), ( "SET (a, b) = ((SELECT 22 FROM tbl1, (SELECT 1 FROM tbl2)), SELECT 33 FROM tbl3)", "SET (a, b) = ((SELECT 22 FROM tbl1, (SELECT 1 FROM tbl2)), (SELECT 33 FROM tbl3))", ), ] { multi_variable_dialects.one_statement_parses_to(sql, canonical); } let error_sqls = [ ("SET (a, b, c) = (1, 2, 3", "Expected: ), found: EOF"), ("SET (a, b, c) = 1, 2, 3", "Expected: (, found: 1"), ( "SET (a) = ((SELECT 22 FROM tbl1)", "Expected: ), found: EOF", ), ( "SET (a) = ((SELECT 22 FROM tbl1) (SELECT 22 FROM tbl1))", "Expected: ), found: (", ), ]; for (sql, error) in error_sqls { assert_eq!( ParserError::ParserError(error.to_string()), multi_variable_dialects .parse_sql_statements(sql) .unwrap_err() ); } one_statement_parses_to("SET SOMETHING TO '1'", "SET SOMETHING = '1'"); } #[test] fn parse_set_role_as_variable() { match verified_stmt("SET role = 'foobar'") { Statement::Set(Set::SingleAssignment { scope, hivevar, variable, values, }) => { assert_eq!(scope, None); assert!(!hivevar); assert_eq!(variable, ObjectName::from(vec!["role".into()])); assert_eq!( values, vec![Expr::Value( (Value::SingleQuotedString("foobar".into())).with_empty_span() )] ); } _ => unreachable!(), } } #[test] fn parse_double_colon_cast_at_timezone() { let sql = "SELECT '2001-01-01T00:00:00.000Z'::TIMESTAMP AT TIME ZONE 'Europe/Brussels' FROM t"; let select = verified_only_select(sql); assert_eq!( &Expr::AtTimeZone { timestamp: Box::new(Expr::Cast { kind: CastKind::DoubleColon, expr: Box::new(Expr::Value( (Value::SingleQuotedString("2001-01-01T00:00:00.000Z".to_string())) .with_empty_span() )), data_type: DataType::Timestamp(None, TimezoneInfo::None), array: false, format: None }), time_zone: Box::new(Expr::Value( (Value::SingleQuotedString("Europe/Brussels".to_string())).with_empty_span() )), }, expr_from_projection(only(&select.projection)), ); } #[test] fn parse_set_time_zone() { match verified_stmt("SET TIMEZONE = 'UTC'") { Statement::Set(Set::SingleAssignment { scope, hivevar, variable, values, }) => { assert_eq!(scope, None); assert!(!hivevar); assert_eq!(variable, ObjectName::from(vec!["TIMEZONE".into()])); assert_eq!( values, vec![Expr::Value( (Value::SingleQuotedString("UTC".into())).with_empty_span() )] ); } _ => unreachable!(), } one_statement_parses_to("SET TIME ZONE TO 'UTC'", "SET TIMEZONE = 'UTC'"); } #[test] fn parse_commit() { match verified_stmt("COMMIT") { Statement::Commit { chain: false, .. } => (), _ => unreachable!(), } match verified_stmt("COMMIT AND CHAIN") { Statement::Commit { chain: true, .. } => (), _ => unreachable!(), } one_statement_parses_to("COMMIT AND NO CHAIN", "COMMIT"); one_statement_parses_to("COMMIT WORK AND NO CHAIN", "COMMIT"); one_statement_parses_to("COMMIT TRANSACTION AND NO CHAIN", "COMMIT"); one_statement_parses_to("COMMIT WORK AND CHAIN", "COMMIT AND CHAIN"); one_statement_parses_to("COMMIT TRANSACTION AND CHAIN", "COMMIT AND CHAIN"); one_statement_parses_to("COMMIT WORK", "COMMIT"); one_statement_parses_to("COMMIT TRANSACTION", "COMMIT"); } #[test] fn parse_end() { one_statement_parses_to("END AND NO CHAIN", "END"); one_statement_parses_to("END WORK AND NO CHAIN", "END"); one_statement_parses_to("END TRANSACTION AND NO CHAIN", "END"); one_statement_parses_to("END WORK AND CHAIN", "END AND CHAIN"); one_statement_parses_to("END TRANSACTION AND CHAIN", "END AND CHAIN"); one_statement_parses_to("END WORK", "END"); one_statement_parses_to("END TRANSACTION", "END"); // MS-SQL syntax let dialects = all_dialects_where(|d| d.supports_end_transaction_modifier()); dialects.verified_stmt("END TRY"); dialects.verified_stmt("END CATCH"); } #[test] fn parse_rollback() { match verified_stmt("ROLLBACK") { Statement::Rollback { chain: false, savepoint: None, } => (), _ => unreachable!(), } match verified_stmt("ROLLBACK AND CHAIN") { Statement::Rollback { chain: true, savepoint: None, } => (), _ => unreachable!(), } match verified_stmt("ROLLBACK TO SAVEPOINT test1") { Statement::Rollback { chain: false, savepoint, } => { assert_eq!(savepoint, Some(Ident::new("test1"))); } _ => unreachable!(), } match verified_stmt("ROLLBACK AND CHAIN TO SAVEPOINT test1") { Statement::Rollback { chain: true, savepoint, } => { assert_eq!(savepoint, Some(Ident::new("test1"))); } _ => unreachable!(), } one_statement_parses_to("ROLLBACK AND NO CHAIN", "ROLLBACK"); one_statement_parses_to("ROLLBACK WORK AND NO CHAIN", "ROLLBACK"); one_statement_parses_to("ROLLBACK TRANSACTION AND NO CHAIN", "ROLLBACK"); one_statement_parses_to("ROLLBACK WORK AND CHAIN", "ROLLBACK AND CHAIN"); one_statement_parses_to("ROLLBACK TRANSACTION AND CHAIN", "ROLLBACK AND CHAIN"); one_statement_parses_to("ROLLBACK WORK", "ROLLBACK"); one_statement_parses_to("ROLLBACK TRANSACTION", "ROLLBACK"); one_statement_parses_to("ROLLBACK TO test1", "ROLLBACK TO SAVEPOINT test1"); one_statement_parses_to( "ROLLBACK AND CHAIN TO test1", "ROLLBACK AND CHAIN TO SAVEPOINT test1", ); } #[test] #[should_panic(expected = "Parse results with GenericDialect are different from PostgreSqlDialect")] fn ensure_multiple_dialects_are_tested() { // The SQL here must be parsed differently by different dialects. // At the time of writing, `@foo` is accepted as a valid identifier // by the Generic and the MSSQL dialect, but not by Postgres and ANSI. let _ = parse_sql_statements("SELECT @foo"); } #[test] fn parse_create_index() { let sql = "CREATE UNIQUE INDEX IF NOT EXISTS idx_name ON test(name, age DESC)"; let indexed_columns: Vec = vec![ IndexColumn { operator_class: None, column: OrderByExpr { expr: Expr::Identifier(Ident::new("name")), with_fill: None, options: OrderByOptions { asc: None, nulls_first: None, }, }, }, IndexColumn { operator_class: None, column: OrderByExpr { expr: Expr::Identifier(Ident::new("age")), with_fill: None, options: OrderByOptions { asc: Some(false), nulls_first: None, }, }, }, ]; match verified_stmt(sql) { Statement::CreateIndex(CreateIndex { name: Some(name), table_name, columns, unique, if_not_exists, .. }) => { assert_eq!("idx_name", name.to_string()); assert_eq!("test", table_name.to_string()); assert_eq!(indexed_columns, columns); assert!(unique); assert!(if_not_exists) } _ => unreachable!(), } } #[test] fn test_create_index_with_using_function() { let sql = "CREATE UNIQUE INDEX IF NOT EXISTS idx_name ON test USING BTREE (name, age DESC)"; let indexed_columns: Vec = vec![ IndexColumn { operator_class: None, column: OrderByExpr { expr: Expr::Identifier(Ident::new("name")), with_fill: None, options: OrderByOptions { asc: None, nulls_first: None, }, }, }, IndexColumn { operator_class: None, column: OrderByExpr { expr: Expr::Identifier(Ident::new("age")), with_fill: None, options: OrderByOptions { asc: Some(false), nulls_first: None, }, }, }, ]; match verified_stmt(sql) { Statement::CreateIndex(CreateIndex { name: Some(name), table_name, using, columns, unique, concurrently, if_not_exists, include, nulls_distinct: None, with, predicate: None, index_options, alter_options, }) => { assert_eq!("idx_name", name.to_string()); assert_eq!("test", table_name.to_string()); assert_eq!("BTREE", using.unwrap().to_string()); assert_eq!(indexed_columns, columns); assert!(unique); assert!(!concurrently); assert!(if_not_exists); assert!(include.is_empty()); assert!(with.is_empty()); assert!(index_options.is_empty()); assert!(alter_options.is_empty()); } _ => unreachable!(), } } #[test] fn test_create_index_with_with_clause() { let sql = "CREATE UNIQUE INDEX title_idx ON films(title) WITH (fillfactor = 70, single_param)"; let indexed_columns: Vec = vec![IndexColumn { column: OrderByExpr { expr: Expr::Identifier(Ident::new("title")), options: OrderByOptions { asc: None, nulls_first: None, }, with_fill: None, }, operator_class: None, }]; let with_parameters = vec![ Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("fillfactor"))), op: BinaryOperator::Eq, right: Box::new(Expr::value(number("70"))), }, Expr::Identifier(Ident::new("single_param")), ]; let dialects = all_dialects_where(|d| d.supports_create_index_with_clause()); match dialects.verified_stmt(sql) { Statement::CreateIndex(CreateIndex { name: Some(name), table_name, using: None, columns, unique, concurrently, if_not_exists, include, nulls_distinct: None, with, predicate: None, index_options, alter_options, }) => { pretty_assertions::assert_eq!("title_idx", name.to_string()); pretty_assertions::assert_eq!("films", table_name.to_string()); pretty_assertions::assert_eq!(indexed_columns, columns); assert!(unique); assert!(!concurrently); assert!(!if_not_exists); assert!(include.is_empty()); pretty_assertions::assert_eq!(with_parameters, with); assert!(index_options.is_empty()); assert!(alter_options.is_empty()); } _ => unreachable!(), } } #[test] fn parse_drop_index() { let sql = "DROP INDEX idx_a"; match verified_stmt(sql) { Statement::Drop { names, object_type, .. } => { assert_eq!( vec!["idx_a"], names.iter().map(ToString::to_string).collect::>() ); assert_eq!(ObjectType::Index, object_type); } _ => unreachable!(), } } #[test] fn parse_create_role() { let sql = "CREATE ROLE consultant"; match verified_stmt(sql) { Statement::CreateRole(create_role) => { assert_eq_vec(&["consultant"], &create_role.names); } _ => unreachable!(), } let sql = "CREATE ROLE IF NOT EXISTS mysql_a, mysql_b"; match verified_stmt(sql) { Statement::CreateRole(create_role) => { assert_eq_vec(&["mysql_a", "mysql_b"], &create_role.names); assert!(create_role.if_not_exists); } _ => unreachable!(), } } #[test] fn parse_drop_role() { let sql = "DROP ROLE abc"; match verified_stmt(sql) { Statement::Drop { names, object_type, if_exists, .. } => { assert_eq_vec(&["abc"], &names); assert_eq!(ObjectType::Role, object_type); assert!(!if_exists); } _ => unreachable!(), }; let sql = "DROP ROLE IF EXISTS def, magician, quaternion"; match verified_stmt(sql) { Statement::Drop { names, object_type, if_exists, .. } => { assert_eq_vec(&["def", "magician", "quaternion"], &names); assert_eq!(ObjectType::Role, object_type); assert!(if_exists); } _ => unreachable!(), } } #[test] fn parse_grant() { let sql = "GRANT SELECT, INSERT, UPDATE (shape, size), USAGE, DELETE, TRUNCATE, REFERENCES, TRIGGER, CONNECT, CREATE, EXECUTE, TEMPORARY, DROP ON abc, def TO xyz, m WITH GRANT OPTION GRANTED BY jj"; match verified_stmt(sql) { Statement::Grant(Grant { privileges, objects, grantees, with_grant_option, granted_by, .. }) => match (privileges, objects) { (Privileges::Actions(actions), Some(GrantObjects::Tables(objects))) => { assert_eq!( vec![ Action::Select { columns: None }, Action::Insert { columns: None }, Action::Update { columns: Some(vec![ Ident { value: "shape".into(), quote_style: None, span: Span::empty(), }, Ident { value: "size".into(), quote_style: None, span: Span::empty(), }, ]) }, Action::Usage, Action::Delete, Action::Truncate, Action::References { columns: None }, Action::Trigger, Action::Connect, Action::Create { obj_type: None }, Action::Execute { obj_type: None }, Action::Temporary, Action::Drop, ], actions ); assert_eq_vec(&["abc", "def"], &objects); assert_eq_vec(&["xyz", "m"], &grantees); assert!(with_grant_option); assert_eq!("jj", granted_by.unwrap().to_string()); } _ => unreachable!(), }, _ => unreachable!(), } let sql2 = "GRANT INSERT ON ALL TABLES IN SCHEMA public TO browser"; match verified_stmt(sql2) { Statement::Grant(Grant { privileges, objects, grantees, with_grant_option, .. }) => match (privileges, objects) { (Privileges::Actions(actions), Some(GrantObjects::AllTablesInSchema { schemas })) => { assert_eq!(vec![Action::Insert { columns: None }], actions); assert_eq_vec(&["public"], &schemas); assert_eq_vec(&["browser"], &grantees); assert!(!with_grant_option); } _ => unreachable!(), }, _ => unreachable!(), } let sql3 = "GRANT USAGE, SELECT ON SEQUENCE p TO u"; match verified_stmt(sql3) { Statement::Grant(Grant { privileges, objects, grantees, granted_by, .. }) => match (privileges, objects, granted_by) { (Privileges::Actions(actions), Some(GrantObjects::Sequences(objects)), None) => { assert_eq!( vec![Action::Usage, Action::Select { columns: None }], actions ); assert_eq_vec(&["p"], &objects); assert_eq_vec(&["u"], &grantees); } _ => unreachable!(), }, _ => unreachable!(), } let sql4 = "GRANT ALL PRIVILEGES ON aa, b TO z"; match verified_stmt(sql4) { Statement::Grant(Grant { privileges, .. }) => { assert_eq!( Privileges::All { with_privileges_keyword: true }, privileges ); } _ => unreachable!(), } let sql5 = "GRANT ALL ON SCHEMA aa, b TO z"; match verified_stmt(sql5) { Statement::Grant(Grant { privileges, objects, .. }) => match (privileges, objects) { ( Privileges::All { with_privileges_keyword, }, Some(GrantObjects::Schemas(schemas)), ) => { assert!(!with_privileges_keyword); assert_eq_vec(&["aa", "b"], &schemas); } _ => unreachable!(), }, _ => unreachable!(), } let sql6 = "GRANT USAGE ON ALL SEQUENCES IN SCHEMA bus TO a, beta WITH GRANT OPTION"; match verified_stmt(sql6) { Statement::Grant(Grant { privileges, objects, .. }) => match (privileges, objects) { ( Privileges::Actions(actions), Some(GrantObjects::AllSequencesInSchema { schemas }), ) => { assert_eq!(vec![Action::Usage], actions); assert_eq_vec(&["bus"], &schemas); } _ => unreachable!(), }, _ => unreachable!(), } verified_stmt("GRANT SELECT ON ALL TABLES IN SCHEMA db1.sc1 TO ROLE role1"); verified_stmt("GRANT SELECT ON ALL TABLES IN SCHEMA db1.sc1 TO ROLE role1 WITH GRANT OPTION"); verified_stmt("GRANT SELECT ON ALL TABLES IN SCHEMA db1.sc1 TO DATABASE ROLE role1"); verified_stmt("GRANT SELECT ON ALL TABLES IN SCHEMA db1.sc1 TO APPLICATION role1"); verified_stmt("GRANT SELECT ON ALL TABLES IN SCHEMA db1.sc1 TO APPLICATION ROLE role1"); verified_stmt("GRANT SELECT ON ALL TABLES IN SCHEMA db1.sc1 TO SHARE share1"); verified_stmt("GRANT SELECT ON ALL VIEWS IN SCHEMA db1.sc1 TO ROLE role1"); verified_stmt("GRANT SELECT ON ALL MATERIALIZED VIEWS IN SCHEMA db1.sc1 TO ROLE role1"); verified_stmt("GRANT SELECT ON ALL EXTERNAL TABLES IN SCHEMA db1.sc1 TO ROLE role1"); verified_stmt("GRANT USAGE ON ALL FUNCTIONS IN SCHEMA db1.sc1 TO ROLE role1"); verified_stmt("GRANT USAGE ON SCHEMA sc1 TO a:b"); verified_stmt("GRANT USAGE ON SCHEMA sc1 TO GROUP group1"); verified_stmt("GRANT OWNERSHIP ON ALL TABLES IN SCHEMA DEV_STAS_ROGOZHIN TO ROLE ANALYST"); verified_stmt("GRANT OWNERSHIP ON ALL TABLES IN SCHEMA DEV_STAS_ROGOZHIN TO ROLE ANALYST COPY CURRENT GRANTS"); verified_stmt("GRANT OWNERSHIP ON ALL TABLES IN SCHEMA DEV_STAS_ROGOZHIN TO ROLE ANALYST REVOKE CURRENT GRANTS"); verified_stmt("GRANT USAGE ON DATABASE db1 TO ROLE role1"); verified_stmt("GRANT USAGE ON WAREHOUSE wh1 TO ROLE role1"); verified_stmt("GRANT OWNERSHIP ON INTEGRATION int1 TO ROLE role1"); verified_stmt("GRANT SELECT ON VIEW view1 TO ROLE role1"); verified_stmt("GRANT EXEC ON my_sp TO runner"); verified_stmt("GRANT UPDATE ON my_table TO updater_role AS dbo"); all_dialects_where(|d| d.identifier_quote_style("none") == Some('[')) .verified_stmt("GRANT SELECT ON [my_table] TO [public]"); verified_stmt("GRANT SELECT ON FUTURE SCHEMAS IN DATABASE db1 TO ROLE role1"); verified_stmt("GRANT SELECT ON FUTURE TABLES IN SCHEMA db1.sc1 TO ROLE role1"); verified_stmt("GRANT SELECT ON FUTURE EXTERNAL TABLES IN SCHEMA db1.sc1 TO ROLE role1"); verified_stmt("GRANT SELECT ON FUTURE VIEWS IN SCHEMA db1.sc1 TO ROLE role1"); verified_stmt("GRANT SELECT ON FUTURE MATERIALIZED VIEWS IN SCHEMA db1.sc1 TO ROLE role1"); verified_stmt("GRANT SELECT ON FUTURE SEQUENCES IN SCHEMA db1.sc1 TO ROLE role1"); verified_stmt("GRANT USAGE ON PROCEDURE db1.sc1.foo(INT) TO ROLE role1"); verified_stmt("GRANT USAGE ON FUNCTION db1.sc1.foo(INT) TO ROLE role1"); verified_stmt("GRANT ROLE role1 TO ROLE role2"); verified_stmt("GRANT ROLE role1 TO USER user"); verified_stmt("GRANT CREATE SCHEMA ON DATABASE db1 TO ROLE role1"); } #[test] fn parse_deny() { let sql = "DENY INSERT, DELETE ON users TO analyst CASCADE AS admin"; match verified_stmt(sql) { Statement::Deny(deny) => { assert_eq!( Privileges::Actions(vec![Action::Insert { columns: None }, Action::Delete]), deny.privileges ); assert_eq!( &GrantObjects::Tables(vec![ObjectName::from(vec![Ident::new("users")])]), &deny.objects ); assert_eq_vec(&["analyst"], &deny.grantees); assert_eq!(Some(CascadeOption::Cascade), deny.cascade); assert_eq!(Some(Ident::from("admin")), deny.granted_by); } _ => unreachable!(), } verified_stmt("DENY SELECT, INSERT, UPDATE, DELETE ON db1.sc1 TO role1, role2"); verified_stmt("DENY ALL ON db1.sc1 TO role1"); verified_stmt("DENY EXEC ON my_sp TO runner"); all_dialects_where(|d| d.identifier_quote_style("none") == Some('[')) .verified_stmt("DENY SELECT ON [my_table] TO [public]"); } #[test] fn test_revoke() { let sql = "REVOKE ALL PRIVILEGES ON users, auth FROM analyst"; match verified_stmt(sql) { Statement::Revoke(Revoke { privileges, objects: Some(GrantObjects::Tables(tables)), grantees, granted_by, cascade, }) => { assert_eq!( Privileges::All { with_privileges_keyword: true }, privileges ); assert_eq_vec(&["users", "auth"], &tables); assert_eq_vec(&["analyst"], &grantees); assert_eq!(cascade, None); assert_eq!(None, granted_by); } _ => unreachable!(), } } #[test] fn test_revoke_with_cascade() { let sql = "REVOKE ALL PRIVILEGES ON users, auth FROM analyst CASCADE"; match all_dialects_except(|d| d.is::()).verified_stmt(sql) { Statement::Revoke(Revoke { privileges, objects: Some(GrantObjects::Tables(tables)), grantees, granted_by, cascade, }) => { assert_eq!( Privileges::All { with_privileges_keyword: true }, privileges ); assert_eq_vec(&["users", "auth"], &tables); assert_eq_vec(&["analyst"], &grantees); assert_eq!(cascade, Some(CascadeOption::Cascade)); assert_eq!(None, granted_by); } _ => unreachable!(), } } #[test] fn parse_merge() { let sql = "MERGE INTO s.bar AS dest USING (SELECT * FROM s.foo) AS stg ON dest.D = stg.D AND dest.E = stg.E WHEN NOT MATCHED THEN INSERT (A, B, C) VALUES (stg.A, stg.B, stg.C) WHEN MATCHED AND dest.A = 'a' THEN UPDATE SET dest.F = stg.F, dest.G = stg.G WHEN MATCHED THEN DELETE"; let sql_no_into = "MERGE s.bar AS dest USING (SELECT * FROM s.foo) AS stg ON dest.D = stg.D AND dest.E = stg.E WHEN NOT MATCHED THEN INSERT (A, B, C) VALUES (stg.A, stg.B, stg.C) WHEN MATCHED AND dest.A = 'a' THEN UPDATE SET dest.F = stg.F, dest.G = stg.G WHEN MATCHED THEN DELETE"; match (verified_stmt(sql), verified_stmt(sql_no_into)) { ( Statement::Merge(Merge { into, table, source, on, clauses, .. }), Statement::Merge(Merge { into: no_into, table: table_no_into, source: source_no_into, on: on_no_into, clauses: clauses_no_into, .. }), ) => { assert!(into); assert!(!no_into); assert_eq!( table, TableFactor::Table { name: ObjectName::from(vec![Ident::new("s"), Ident::new("bar")]), alias: table_alias(true, "dest"), args: None, with_hints: vec![], version: None, partitions: vec![], with_ordinality: false, json_path: None, sample: None, index_hints: vec![], } ); assert_eq!(table, table_no_into); assert_eq!( source, TableFactor::Derived { lateral: false, subquery: Box::new(Query { with: None, body: Box::new(SetExpr::Select(Box::new(Select { select_token: AttachedToken::empty(), optimizer_hints: vec![], distinct: None, select_modifiers: None, top: None, top_before_distinct: false, projection: vec![SelectItem::Wildcard( WildcardAdditionalOptions::default() )], exclude: None, into: None, from: vec![TableWithJoins { relation: table_from_name(ObjectName::from(vec![ Ident::new("s"), Ident::new("foo") ])), joins: vec![], }], lateral_views: vec![], prewhere: None, selection: None, group_by: GroupByExpr::Expressions(vec![], vec![]), cluster_by: vec![], distribute_by: vec![], sort_by: vec![], having: None, named_window: vec![], window_before_qualify: false, qualify: None, value_table_mode: None, connect_by: vec![], flavor: SelectFlavor::Standard, }))), order_by: None, limit_clause: None, fetch: None, locks: vec![], for_clause: None, settings: None, format_clause: None, pipe_operators: vec![], }), alias: table_alias(true, "stg"), sample: None, } ); assert_eq!(source, source_no_into); assert_eq!( on, Box::new(Expr::BinaryOp { left: Box::new(Expr::BinaryOp { left: Box::new(Expr::CompoundIdentifier(vec![ Ident::new("dest"), Ident::new("D"), ])), op: BinaryOperator::Eq, right: Box::new(Expr::CompoundIdentifier(vec![ Ident::new("stg"), Ident::new("D"), ])), }), op: BinaryOperator::And, right: Box::new(Expr::BinaryOp { left: Box::new(Expr::CompoundIdentifier(vec![ Ident::new("dest"), Ident::new("E"), ])), op: BinaryOperator::Eq, right: Box::new(Expr::CompoundIdentifier(vec![ Ident::new("stg"), Ident::new("E"), ])), }), }) ); assert_eq!(on, on_no_into); assert_eq!( clauses, vec![ MergeClause { when_token: AttachedToken::empty(), clause_kind: MergeClauseKind::NotMatched, predicate: None, action: MergeAction::Insert(MergeInsertExpr { insert_token: AttachedToken::empty(), columns: vec![ Ident::new("A").into(), Ident::new("B").into(), Ident::new("C").into() ], kind_token: AttachedToken::empty(), kind: MergeInsertKind::Values(Values { value_keyword: false, explicit_row: false, rows: vec![Parens::with_empty_span(vec![ Expr::CompoundIdentifier(vec![ Ident::new("stg"), Ident::new("A") ]), Expr::CompoundIdentifier(vec![ Ident::new("stg"), Ident::new("B") ]), Expr::CompoundIdentifier(vec![ Ident::new("stg"), Ident::new("C") ]), ])] }), insert_predicate: None, }), }, MergeClause { when_token: AttachedToken::empty(), clause_kind: MergeClauseKind::Matched, predicate: Some(Expr::BinaryOp { left: Box::new(Expr::CompoundIdentifier(vec![ Ident::new("dest"), Ident::new("A"), ])), op: BinaryOperator::Eq, right: Box::new(Expr::Value( (Value::SingleQuotedString("a".to_string())).with_empty_span() )), }), action: MergeAction::Update(MergeUpdateExpr { update_token: AttachedToken::empty(), assignments: vec![ Assignment { target: AssignmentTarget::ColumnName(ObjectName::from(vec![ Ident::new("dest"), Ident::new("F") ])), value: Expr::CompoundIdentifier(vec![ Ident::new("stg"), Ident::new("F"), ]), }, Assignment { target: AssignmentTarget::ColumnName(ObjectName::from(vec![ Ident::new("dest"), Ident::new("G") ])), value: Expr::CompoundIdentifier(vec![ Ident::new("stg"), Ident::new("G"), ]), }, ], update_predicate: None, delete_predicate: None, }), }, MergeClause { when_token: AttachedToken::empty(), clause_kind: MergeClauseKind::Matched, predicate: None, action: MergeAction::Delete { delete_token: AttachedToken::empty(), }, }, ] ); assert_eq!(clauses, clauses_no_into); } _ => unreachable!(), }; let sql = "MERGE INTO s.bar AS dest USING newArrivals AS S ON (1 > 1) WHEN NOT MATCHED THEN INSERT VALUES (stg.A, stg.B, stg.C)"; verified_stmt(sql); // MERGE with predicates let sql = "\ MERGE INTO FOO \ USING FOO_IMPORT \ ON (FOO.ID = FOO_IMPORT.ID) \ WHEN MATCHED THEN \ UPDATE SET FOO.NAME = FOO_IMPORT.NAME \ WHERE 1 = 1 \ DELETE WHERE FOO.NAME LIKE '%.DELETE' \ WHEN NOT MATCHED THEN \ INSERT (ID, NAME) \ VALUES (FOO_IMPORT.ID, UPPER(FOO_IMPORT.NAME)) \ WHERE NOT FOO_IMPORT.NAME LIKE '%.DO_NOT_INSERT'"; all_dialects().verified_stmt(sql); // MERGE with simple insert columns let sql = "\ MERGE INTO FOO USING FOO_IMPORT ON (FOO.ID = FOO_IMPORT.ID) \ WHEN NOT MATCHED THEN \ INSERT (ID, NAME) \ VALUES (1, 'abc')"; all_dialects().verified_stmt(sql); // MERGE with qualified insert columns let sql = "\ MERGE INTO FOO USING FOO_IMPORT ON (FOO.ID = FOO_IMPORT.ID) \ WHEN NOT MATCHED THEN \ INSERT (FOO.ID, FOO.NAME) \ VALUES (1, 'abc')"; all_dialects().verified_stmt(sql); // MERGE with schema qualified insert columns let sql = "\ MERGE INTO PLAYGROUND.FOO USING FOO_IMPORT ON (PLAYGROUND.FOO.ID = FOO_IMPORT.ID) \ WHEN NOT MATCHED THEN \ INSERT (PLAYGROUND.FOO.ID, PLAYGROUND.FOO.NAME) \ VALUES (1, 'abc')"; all_dialects().verified_stmt(sql); } #[test] fn test_merge_in_cte() { verified_only_select( "WITH x AS (\ MERGE INTO t USING (VALUES (1)) ON 1 = 1 \ WHEN MATCHED THEN DELETE \ RETURNING *\ ) SELECT * FROM x", ); } #[test] fn test_merge_with_returning() { let sql = "MERGE INTO wines AS w \ USING wine_stock_changes AS s \ ON s.winename = w.winename \ WHEN NOT MATCHED AND s.stock_delta > 0 THEN INSERT VALUES (s.winename, s.stock_delta) \ WHEN MATCHED AND w.stock + s.stock_delta > 0 THEN UPDATE SET stock = w.stock + s.stock_delta \ WHEN MATCHED THEN DELETE \ RETURNING merge_action(), w.*"; verified_stmt(sql); } #[test] fn test_merge_with_output() { let sql = "MERGE INTO target_table USING source_table \ ON target_table.id = source_table.oooid \ WHEN MATCHED THEN \ UPDATE SET target_table.description = source_table.description \ WHEN NOT MATCHED THEN \ INSERT (ID, description) VALUES (source_table.id, source_table.description) \ OUTPUT inserted.* INTO log_target"; verified_stmt(sql); } #[test] fn test_merge_with_output_without_into() { let sql = "MERGE INTO a USING b ON a.id = b.id \ WHEN MATCHED THEN DELETE \ OUTPUT inserted.*"; verified_stmt(sql); } #[test] fn test_merge_into_using_table() { let sql = "MERGE INTO target_table USING source_table \ ON target_table.id = source_table.oooid \ WHEN MATCHED THEN \ UPDATE SET target_table.description = source_table.description \ WHEN NOT MATCHED THEN \ INSERT (ID, description) VALUES (source_table.id, source_table.description)"; verified_stmt(sql); } #[test] fn test_merge_with_delimiter() { let sql = "MERGE INTO target_table USING source_table \ ON target_table.id = source_table.oooid \ WHEN MATCHED THEN \ UPDATE SET target_table.description = source_table.description \ WHEN NOT MATCHED THEN \ INSERT (ID, description) VALUES (source_table.id, source_table.description);"; match parse_sql_statements(sql) { Ok(_) => {} _ => unreachable!(), } } #[test] fn test_merge_invalid_statements() { let dialects = all_dialects(); for (sql, err_msg) in [ ( "MERGE INTO T USING U ON TRUE WHEN NOT MATCHED THEN UPDATE SET a = b", "UPDATE is not allowed in a NOT MATCHED merge clause", ), ( "MERGE INTO T USING U ON TRUE WHEN NOT MATCHED THEN DELETE", "DELETE is not allowed in a NOT MATCHED merge clause", ), ( "MERGE INTO T USING U ON TRUE WHEN MATCHED THEN INSERT(a) VALUES(b)", "INSERT is not allowed in a MATCHED merge clause", ), ] { let res = dialects.parse_sql_statements(sql); assert_eq!( ParserError::ParserError(err_msg.to_string()), res.unwrap_err() ); } } #[test] fn test_lock() { let sql = "SELECT * FROM student WHERE id = '1' FOR UPDATE"; let mut ast = verified_query(sql); assert_eq!(ast.locks.len(), 1); let lock = ast.locks.pop().unwrap(); assert_eq!(lock.lock_type, LockType::Update); assert!(lock.of.is_none()); assert!(lock.nonblock.is_none()); let sql = "SELECT * FROM student WHERE id = '1' FOR SHARE"; let mut ast = verified_query(sql); assert_eq!(ast.locks.len(), 1); let lock = ast.locks.pop().unwrap(); assert_eq!(lock.lock_type, LockType::Share); assert!(lock.of.is_none()); assert!(lock.nonblock.is_none()); } #[test] fn test_lock_table() { let sql = "SELECT * FROM student WHERE id = '1' FOR UPDATE OF school"; let mut ast = verified_query(sql); assert_eq!(ast.locks.len(), 1); let lock = ast.locks.pop().unwrap(); assert_eq!(lock.lock_type, LockType::Update); assert_eq!( lock.of.unwrap(), ObjectName::from(vec![Ident { value: "school".to_string(), quote_style: None, span: Span::empty(), }]) ); assert!(lock.nonblock.is_none()); let sql = "SELECT * FROM student WHERE id = '1' FOR SHARE OF school"; let mut ast = verified_query(sql); assert_eq!(ast.locks.len(), 1); let lock = ast.locks.pop().unwrap(); assert_eq!(lock.lock_type, LockType::Share); assert_eq!( lock.of.unwrap(), ObjectName::from(vec![Ident { value: "school".to_string(), quote_style: None, span: Span::empty(), }]) ); assert!(lock.nonblock.is_none()); let sql = "SELECT * FROM student WHERE id = '1' FOR SHARE OF school FOR UPDATE OF student"; let mut ast = verified_query(sql); assert_eq!(ast.locks.len(), 2); let lock = ast.locks.remove(0); assert_eq!(lock.lock_type, LockType::Share); assert_eq!( lock.of.unwrap(), ObjectName::from(vec![Ident { value: "school".to_string(), quote_style: None, span: Span::empty(), }]) ); assert!(lock.nonblock.is_none()); let lock = ast.locks.remove(0); assert_eq!(lock.lock_type, LockType::Update); assert_eq!( lock.of.unwrap(), ObjectName::from(vec![Ident { value: "student".to_string(), quote_style: None, span: Span::empty(), }]) ); assert!(lock.nonblock.is_none()); } #[test] fn test_lock_nonblock() { let sql = "SELECT * FROM student WHERE id = '1' FOR UPDATE OF school SKIP LOCKED"; let mut ast = verified_query(sql); assert_eq!(ast.locks.len(), 1); let lock = ast.locks.pop().unwrap(); assert_eq!(lock.lock_type, LockType::Update); assert_eq!( lock.of.unwrap(), ObjectName::from(vec![Ident { value: "school".to_string(), quote_style: None, span: Span::empty(), }]) ); assert_eq!(lock.nonblock.unwrap(), NonBlock::SkipLocked); let sql = "SELECT * FROM student WHERE id = '1' FOR SHARE OF school NOWAIT"; let mut ast = verified_query(sql); assert_eq!(ast.locks.len(), 1); let lock = ast.locks.pop().unwrap(); assert_eq!(lock.lock_type, LockType::Share); assert_eq!( lock.of.unwrap(), ObjectName::from(vec![Ident { value: "school".to_string(), quote_style: None, span: Span::empty(), }]) ); assert_eq!(lock.nonblock.unwrap(), NonBlock::Nowait); } #[test] fn test_placeholder() { let dialects = TestedDialects::new(vec![ Box::new(GenericDialect {}), Box::new(DuckDbDialect {}), Box::new(PostgreSqlDialect {}), Box::new(MsSqlDialect {}), Box::new(AnsiDialect {}), Box::new(BigQueryDialect {}), Box::new(SnowflakeDialect {}), // Note: `$` is the starting word for the HiveDialect identifier // Box::new(sqlparser::dialect::HiveDialect {}), ]); let sql = "SELECT * FROM student WHERE id = $Id1"; let ast = dialects.verified_only_select(sql); assert_eq!( ast.selection, Some(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("id"))), op: BinaryOperator::Eq, right: Box::new(Expr::Value( (Value::Placeholder("$Id1".into())).with_empty_span() )), }) ); let ast = dialects.verified_query("SELECT * FROM student LIMIT $1 OFFSET $2"); let expected_limit_clause = LimitClause::LimitOffset { limit: Some(Expr::Value( (Value::Placeholder("$1".into())).with_empty_span(), )), offset: Some(Offset { value: Expr::Value((Value::Placeholder("$2".into())).with_empty_span()), rows: OffsetRows::None, }), limit_by: vec![], }; assert_eq!(ast.limit_clause, Some(expected_limit_clause)); let dialects = TestedDialects::new(vec![ Box::new(GenericDialect {}), Box::new(DuckDbDialect {}), // Note: `?` is for jsonb operators in PostgreSqlDialect // Box::new(PostgreSqlDialect {}), Box::new(MsSqlDialect {}), Box::new(AnsiDialect {}), Box::new(BigQueryDialect {}), Box::new(SnowflakeDialect {}), // Note: `$` is the starting word for the HiveDialect identifier // Box::new(sqlparser::dialect::HiveDialect {}), ]); let sql = "SELECT * FROM student WHERE id = ?"; let ast = dialects.verified_only_select(sql); assert_eq!( ast.selection, Some(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("id"))), op: BinaryOperator::Eq, right: Box::new(Expr::Value( (Value::Placeholder("?".into())).with_empty_span() )), }) ); let sql = "SELECT $fromage_français, :x, ?123"; let ast = dialects.verified_only_select(sql); assert_eq!( ast.projection, vec![ UnnamedExpr(Expr::Value( (Value::Placeholder("$fromage_français".into())).with_empty_span() )), UnnamedExpr(Expr::Value( (Value::Placeholder(":x".into())).with_empty_span() )), UnnamedExpr(Expr::Value( (Value::Placeholder("?123".into())).with_empty_span() )), ] ); } #[test] fn all_keywords_sorted() { // assert!(ALL_KEYWORDS.is_sorted()) let mut copy = Vec::from(ALL_KEYWORDS); copy.sort_unstable(); assert_eq!(copy, ALL_KEYWORDS) } fn parse_sql_statements(sql: &str) -> Result, ParserError> { all_dialects().parse_sql_statements(sql) } fn one_statement_parses_to(sql: &str, canonical: &str) -> Statement { all_dialects().one_statement_parses_to(sql, canonical) } fn verified_stmt(query: &str) -> Statement { all_dialects().verified_stmt(query) } fn verified_query(query: &str) -> Query { all_dialects().verified_query(query) } fn verified_only_select(query: &str) -> Select { all_dialects().verified_only_select(query) } fn verified_expr(query: &str) -> Expr { all_dialects().verified_expr(query) } #[test] fn parse_offset_and_limit() { let sql = "SELECT foo FROM bar LIMIT 1 OFFSET 2"; let expected_limit_clause = Some(LimitClause::LimitOffset { limit: Some(Expr::value(number("1"))), offset: Some(Offset { value: Expr::value(number("2")), rows: OffsetRows::None, }), limit_by: vec![], }); let ast = verified_query(sql); assert_eq!(ast.limit_clause, expected_limit_clause); // different order is OK one_statement_parses_to("SELECT foo FROM bar OFFSET 2 LIMIT 1", sql); // mysql syntax is ok for some dialects all_dialects_where(|d| d.supports_limit_comma()) .verified_query("SELECT foo FROM bar LIMIT 2, 1"); // expressions are allowed let sql = "SELECT foo FROM bar LIMIT 1 + 2 OFFSET 3 * 4"; let ast = verified_query(sql); let expected_limit_clause = LimitClause::LimitOffset { limit: Some(Expr::BinaryOp { left: Box::new(Expr::value(number("1"))), op: BinaryOperator::Plus, right: Box::new(Expr::value(number("2"))), }), offset: Some(Offset { value: Expr::BinaryOp { left: Box::new(Expr::value(number("3"))), op: BinaryOperator::Multiply, right: Box::new(Expr::value(number("4"))), }, rows: OffsetRows::None, }), limit_by: vec![], }; assert_eq!(ast.limit_clause, Some(expected_limit_clause),); // OFFSET without LIMIT verified_stmt("SELECT foo FROM bar OFFSET 2"); // Can't repeat OFFSET / LIMIT let res = parse_sql_statements("SELECT foo FROM bar OFFSET 2 OFFSET 2"); assert_eq!( ParserError::ParserError("Expected: end of statement, found: OFFSET".to_string()), res.unwrap_err() ); let res = parse_sql_statements("SELECT foo FROM bar LIMIT 2 LIMIT 2"); assert_eq!( ParserError::ParserError("Expected: end of statement, found: LIMIT".to_string()), res.unwrap_err() ); let res = parse_sql_statements("SELECT foo FROM bar OFFSET 2 LIMIT 2 OFFSET 2"); assert_eq!( ParserError::ParserError("Expected: end of statement, found: OFFSET".to_string()), res.unwrap_err() ); } #[test] fn parse_time_functions() { fn test_time_function(func_name: &'static str) { let sql = format!("SELECT {func_name}()"); let select = verified_only_select(&sql); let select_localtime_func_call_ast = Function { name: ObjectName::from(vec![Ident::new(func_name)]), uses_odbc_syntax: false, parameters: FunctionArguments::None, args: FunctionArguments::List(FunctionArgumentList { duplicate_treatment: None, args: vec![], clauses: vec![], }), null_treatment: None, filter: None, over: None, within_group: vec![], }; assert_eq!( &Expr::Function(select_localtime_func_call_ast.clone()), expr_from_projection(&select.projection[0]) ); // Validating Parenthesis let sql_without_parens = format!("SELECT {func_name}"); let mut ast_without_parens = select_localtime_func_call_ast; ast_without_parens.args = FunctionArguments::None; assert_eq!( &Expr::Function(ast_without_parens), expr_from_projection(&verified_only_select(&sql_without_parens).projection[0]) ); } test_time_function("CURRENT_TIMESTAMP"); test_time_function("CURRENT_TIME"); test_time_function("CURRENT_DATE"); test_time_function("LOCALTIME"); test_time_function("LOCALTIMESTAMP"); } #[test] fn parse_position() { assert_eq!( Expr::Position { expr: Box::new(Expr::Value( (Value::SingleQuotedString("@".to_string())).with_empty_span() )), r#in: Box::new(Expr::Identifier(Ident::new("field"))), }, verified_expr("POSITION('@' IN field)"), ); // some dialects (e.g. snowflake) support position as a function call (i.e. without IN) assert_eq!( call( "position", [ Expr::Value((Value::SingleQuotedString("an".to_owned())).with_empty_span()), Expr::Value((Value::SingleQuotedString("banana".to_owned())).with_empty_span()), Expr::value(number("1")), ] ), verified_expr("position('an', 'banana', 1)") ); } #[test] fn parse_position_negative() { let sql = "SELECT POSITION(foo IN) from bar"; let res = parse_sql_statements(sql); assert_eq!( ParserError::ParserError("Expected: (, found: )".to_string()), res.unwrap_err() ); } #[test] fn parse_is_boolean() { use self::Expr::*; let sql = "a IS TRUE"; assert_eq!( IsTrue(Box::new(Identifier(Ident::new("a")))), verified_expr(sql) ); let sql = "a IS NOT TRUE"; assert_eq!( IsNotTrue(Box::new(Identifier(Ident::new("a")))), verified_expr(sql) ); let sql = "a IS FALSE"; assert_eq!( IsFalse(Box::new(Identifier(Ident::new("a")))), verified_expr(sql) ); let sql = "a IS NOT FALSE"; assert_eq!( IsNotFalse(Box::new(Identifier(Ident::new("a")))), verified_expr(sql) ); let sql = "a IS NORMALIZED"; assert_eq!( IsNormalized { expr: Box::new(Identifier(Ident::new("a"))), form: None, negated: false, }, verified_expr(sql) ); let sql = "a IS NOT NORMALIZED"; assert_eq!( IsNormalized { expr: Box::new(Identifier(Ident::new("a"))), form: None, negated: true, }, verified_expr(sql) ); let sql = "a IS NFKC NORMALIZED"; assert_eq!( IsNormalized { expr: Box::new(Identifier(Ident::new("a"))), form: Some(NormalizationForm::NFKC), negated: false, }, verified_expr(sql) ); let sql = "a IS NOT NFKD NORMALIZED"; assert_eq!( IsNormalized { expr: Box::new(Identifier(Ident::new("a"))), form: Some(NormalizationForm::NFKD), negated: true, }, verified_expr(sql) ); let sql = "a IS UNKNOWN"; assert_eq!( IsUnknown(Box::new(Identifier(Ident::new("a")))), verified_expr(sql) ); let sql = "a IS NOT UNKNOWN"; assert_eq!( IsNotUnknown(Box::new(Identifier(Ident::new("a")))), verified_expr(sql) ); verified_stmt("SELECT f FROM foo WHERE field IS TRUE"); verified_stmt("SELECT f FROM foo WHERE field IS NOT TRUE"); verified_stmt("SELECT f FROM foo WHERE field IS FALSE"); verified_stmt("SELECT f FROM foo WHERE field IS NOT FALSE"); verified_stmt("SELECT f FROM foo WHERE field IS NORMALIZED"); verified_stmt("SELECT f FROM foo WHERE field IS NFC NORMALIZED"); verified_stmt("SELECT f FROM foo WHERE field IS NFD NORMALIZED"); verified_stmt("SELECT f FROM foo WHERE field IS NOT NORMALIZED"); verified_stmt("SELECT f FROM foo WHERE field IS NOT NFKC NORMALIZED"); verified_stmt("SELECT f FROM foo WHERE field IS UNKNOWN"); verified_stmt("SELECT f FROM foo WHERE field IS NOT UNKNOWN"); let sql = "SELECT f from foo where field is 0"; let res = parse_sql_statements(sql); assert_eq!( ParserError::ParserError( "Expected: [NOT] NULL | TRUE | FALSE | DISTINCT | [form] NORMALIZED FROM after IS, found: 0" .to_string() ), res.unwrap_err() ); let sql = "SELECT s, s IS XYZ NORMALIZED FROM foo"; let res = parse_sql_statements(sql); assert_eq!( ParserError::ParserError( "Expected: [NOT] NULL | TRUE | FALSE | DISTINCT | [form] NORMALIZED FROM after IS, found: XYZ" .to_string() ), res.unwrap_err() ); let sql = "SELECT s, s IS NFKC FROM foo"; let res = parse_sql_statements(sql); assert_eq!( ParserError::ParserError( "Expected: [NOT] NULL | TRUE | FALSE | DISTINCT | [form] NORMALIZED FROM after IS, found: FROM" .to_string() ), res.unwrap_err() ); let sql = "SELECT s, s IS TRIM(' NFKC ') FROM foo"; let res = parse_sql_statements(sql); assert_eq!( ParserError::ParserError( "Expected: [NOT] NULL | TRUE | FALSE | DISTINCT | [form] NORMALIZED FROM after IS, found: TRIM" .to_string() ), res.unwrap_err() ); } #[test] fn parse_discard() { let sql = "DISCARD ALL"; match verified_stmt(sql) { Statement::Discard { object_type, .. } => assert_eq!(object_type, DiscardObject::ALL), _ => unreachable!(), } let sql = "DISCARD PLANS"; match verified_stmt(sql) { Statement::Discard { object_type, .. } => assert_eq!(object_type, DiscardObject::PLANS), _ => unreachable!(), } let sql = "DISCARD SEQUENCES"; match verified_stmt(sql) { Statement::Discard { object_type, .. } => assert_eq!(object_type, DiscardObject::SEQUENCES), _ => unreachable!(), } let sql = "DISCARD TEMP"; match verified_stmt(sql) { Statement::Discard { object_type, .. } => assert_eq!(object_type, DiscardObject::TEMP), _ => unreachable!(), } } #[test] fn parse_cursor() { let sql = r#"CLOSE my_cursor"#; match verified_stmt(sql) { Statement::Close { cursor } => assert_eq!( cursor, CloseCursor::Specific { name: Ident::new("my_cursor"), } ), _ => unreachable!(), } let sql = r#"CLOSE ALL"#; match verified_stmt(sql) { Statement::Close { cursor } => assert_eq!(cursor, CloseCursor::All), _ => unreachable!(), } } #[test] fn parse_show_functions() { assert_eq!( verified_stmt("SHOW FUNCTIONS LIKE 'pattern'"), Statement::ShowFunctions { filter: Some(ShowStatementFilter::Like("pattern".into())), } ); } #[test] fn parse_cache_table() { let sql = "SELECT a, b, c FROM foo"; let cache_table_name = "cache_table_name"; let table_flag = "flag"; let query = all_dialects().verified_query(sql); assert_eq!( verified_stmt(format!("CACHE TABLE '{cache_table_name}'").as_str()), Statement::Cache { table_flag: None, table_name: ObjectName::from(vec![Ident::with_quote('\'', cache_table_name)]), has_as: false, options: vec![], query: None, } ); assert_eq!( verified_stmt(format!("CACHE {table_flag} TABLE '{cache_table_name}'").as_str()), Statement::Cache { table_flag: Some(ObjectName::from(vec![Ident::new(table_flag)])), table_name: ObjectName::from(vec![Ident::with_quote('\'', cache_table_name)]), has_as: false, options: vec![], query: None, } ); assert_eq!( verified_stmt( format!( "CACHE {table_flag} TABLE '{cache_table_name}' OPTIONS('K1' = 'V1', 'K2' = 0.88)", ) .as_str() ), Statement::Cache { table_flag: Some(ObjectName::from(vec![Ident::new(table_flag)])), table_name: ObjectName::from(vec![Ident::with_quote('\'', cache_table_name)]), has_as: false, options: vec![ SqlOption::KeyValue { key: Ident::with_quote('\'', "K1"), value: Expr::Value((Value::SingleQuotedString("V1".into())).with_empty_span()), }, SqlOption::KeyValue { key: Ident::with_quote('\'', "K2"), value: Expr::value(number("0.88")), }, ], query: None, } ); assert_eq!( verified_stmt( format!( "CACHE {table_flag} TABLE '{cache_table_name}' OPTIONS('K1' = 'V1', 'K2' = 0.88) {sql}", ) .as_str() ), Statement::Cache { table_flag: Some(ObjectName::from(vec![Ident::new(table_flag)])), table_name: ObjectName::from(vec![Ident::with_quote('\'', cache_table_name)]), has_as: false, options: vec![ SqlOption::KeyValue { key: Ident::with_quote('\'', "K1"), value: Expr::Value((Value::SingleQuotedString("V1".into())).with_empty_span()), }, SqlOption::KeyValue { key: Ident::with_quote('\'', "K2"), value: Expr::value(number("0.88")), }, ], query: Some(query.clone().into()), } ); assert_eq!( verified_stmt( format!( "CACHE {table_flag} TABLE '{cache_table_name}' OPTIONS('K1' = 'V1', 'K2' = 0.88) AS {sql}", ) .as_str() ), Statement::Cache { table_flag: Some(ObjectName::from(vec![Ident::new(table_flag)])), table_name: ObjectName::from(vec![Ident::with_quote('\'', cache_table_name)]), has_as: true, options: vec![ SqlOption::KeyValue { key: Ident::with_quote('\'', "K1"), value: Expr::Value((Value::SingleQuotedString("V1".into())).with_empty_span()), }, SqlOption::KeyValue { key: Ident::with_quote('\'', "K2"), value: Expr::value(number("0.88")), }, ], query: Some(query.clone().into()), } ); assert_eq!( verified_stmt(format!("CACHE {table_flag} TABLE '{cache_table_name}' {sql}").as_str()), Statement::Cache { table_flag: Some(ObjectName::from(vec![Ident::new(table_flag)])), table_name: ObjectName::from(vec![Ident::with_quote('\'', cache_table_name)]), has_as: false, options: vec![], query: Some(query.clone().into()), } ); assert_eq!( verified_stmt(format!("CACHE {table_flag} TABLE '{cache_table_name}' AS {sql}").as_str()), Statement::Cache { table_flag: Some(ObjectName::from(vec![Ident::new(table_flag)])), table_name: ObjectName::from(vec![Ident::with_quote('\'', cache_table_name)]), has_as: true, options: vec![], query: Some(query.into()), } ); let res = parse_sql_statements("CACHE TABLE 'table_name' foo"); assert_eq!( ParserError::ParserError( "Expected: SELECT, VALUES, or a subquery in the query body, found: foo".to_string() ), res.unwrap_err() ); let res = parse_sql_statements("CACHE flag TABLE 'table_name' OPTIONS('K1'='V1') foo"); assert_eq!( ParserError::ParserError( "Expected: SELECT, VALUES, or a subquery in the query body, found: foo".to_string() ), res.unwrap_err() ); let res = parse_sql_statements("CACHE TABLE 'table_name' AS foo"); assert_eq!( ParserError::ParserError( "Expected: SELECT, VALUES, or a subquery in the query body, found: foo".to_string() ), res.unwrap_err() ); let res = parse_sql_statements("CACHE flag TABLE 'table_name' OPTIONS('K1'='V1') AS foo"); assert_eq!( ParserError::ParserError( "Expected: SELECT, VALUES, or a subquery in the query body, found: foo".to_string() ), res.unwrap_err() ); let res = parse_sql_statements("CACHE 'table_name'"); assert_eq!( ParserError::ParserError("Expected: a `TABLE` keyword, found: 'table_name'".to_string()), res.unwrap_err() ); let res = parse_sql_statements("CACHE 'table_name' OPTIONS('K1'='V1')"); assert_eq!( ParserError::ParserError("Expected: a `TABLE` keyword, found: OPTIONS".to_string()), res.unwrap_err() ); let res = parse_sql_statements("CACHE flag 'table_name' OPTIONS('K1'='V1')"); assert_eq!( ParserError::ParserError("Expected: a `TABLE` keyword, found: 'table_name'".to_string()), res.unwrap_err() ); } #[test] fn parse_uncache_table() { assert_eq!( verified_stmt("UNCACHE TABLE 'table_name'"), Statement::UNCache { table_name: ObjectName::from(vec![Ident::with_quote('\'', "table_name")]), if_exists: false, } ); assert_eq!( verified_stmt("UNCACHE TABLE IF EXISTS 'table_name'"), Statement::UNCache { table_name: ObjectName::from(vec![Ident::with_quote('\'', "table_name")]), if_exists: true, } ); let res = parse_sql_statements("UNCACHE TABLE 'table_name' foo"); assert_eq!( ParserError::ParserError("Expected: end of statement, found: foo".to_string()), res.unwrap_err() ); let res = parse_sql_statements("UNCACHE 'table_name' foo"); assert_eq!( ParserError::ParserError("Expected: TABLE, found: 'table_name'".to_string()), res.unwrap_err() ); let res = parse_sql_statements("UNCACHE IF EXISTS 'table_name' foo"); assert_eq!( ParserError::ParserError("Expected: TABLE, found: IF".to_string()), res.unwrap_err() ); } #[test] fn parse_deeply_nested_parens_hits_recursion_limits() { let sql = "(".repeat(1000); let res = parse_sql_statements(&sql); assert_eq!(ParserError::RecursionLimitExceeded, res.unwrap_err()); } #[test] fn parse_update_deeply_nested_parens_hits_recursion_limits() { let sql = format!("\nUPDATE\n\n\n\n\n\n\n\n\n\n{}", "(".repeat(1000)); let res = parse_sql_statements(&sql); assert_eq!(ParserError::RecursionLimitExceeded, res.unwrap_err()); } #[test] fn parse_deeply_nested_unary_op_hits_recursion_limits() { let sql = format!("SELECT {}", "+".repeat(1000)); let res = parse_sql_statements(&sql); assert_eq!(ParserError::RecursionLimitExceeded, res.unwrap_err()); } #[test] fn parse_deeply_nested_expr_hits_recursion_limits() { let dialect = GenericDialect {}; let where_clause = make_where_clause(100); let sql = format!("SELECT id, user_id FROM test WHERE {where_clause}"); let res = Parser::new(&dialect) .try_with_sql(&sql) .expect("tokenize to work") .parse_statements(); assert_eq!(res, Err(ParserError::RecursionLimitExceeded)); } #[test] fn parse_deeply_nested_subquery_expr_hits_recursion_limits() { let dialect = GenericDialect {}; let where_clause = make_where_clause(100); let sql = format!("SELECT id, user_id where id IN (select id from t WHERE {where_clause})"); let res = Parser::new(&dialect) .try_with_sql(&sql) .expect("tokenize to work") .parse_statements(); assert_eq!(res, Err(ParserError::RecursionLimitExceeded)); } #[test] fn parse_with_recursion_limit() { let dialect = GenericDialect {}; let where_clause = make_where_clause(20); let sql = format!("SELECT id, user_id FROM test WHERE {where_clause}"); // Expect the statement to parse with default limit let res = Parser::new(&dialect) .try_with_sql(&sql) .expect("tokenize to work") .parse_statements(); assert!(res.is_ok(), "{res:?}"); // limit recursion to something smaller, expect parsing to fail let res = Parser::new(&dialect) .try_with_sql(&sql) .expect("tokenize to work") .with_recursion_limit(20) .parse_statements(); assert_eq!(res, Err(ParserError::RecursionLimitExceeded)); // limit recursion to 50, expect it to succeed let res = Parser::new(&dialect) .try_with_sql(&sql) .expect("tokenize to work") .with_recursion_limit(50) .parse_statements(); assert!(res.is_ok(), "{res:?}"); } #[test] fn parse_escaped_string_with_unescape() { fn assert_mysql_query_value(dialects: &TestedDialects, sql: &str, quoted: &str) { match dialects.one_statement_parses_to(sql, "") { Statement::Query(query) => match *query.body { SetExpr::Select(value) => { let expr = expr_from_projection(only(&value.projection)); assert_eq!( *expr, Expr::Value( (Value::SingleQuotedString(quoted.to_string())).with_empty_span() ) ); } _ => unreachable!(), }, _ => unreachable!(), }; } let escaping_dialects = &all_dialects_where(|dialect| dialect.supports_string_literal_backslash_escape()); let no_wildcard_exception = &all_dialects_where(|dialect| { dialect.supports_string_literal_backslash_escape() && !dialect.ignores_wildcard_escapes() }); let with_wildcard_exception = &all_dialects_where(|dialect| { dialect.supports_string_literal_backslash_escape() && dialect.ignores_wildcard_escapes() }); let sql = r"SELECT 'I\'m fine'"; assert_mysql_query_value(escaping_dialects, sql, "I'm fine"); let sql = r#"SELECT 'I''m fine'"#; assert_mysql_query_value(escaping_dialects, sql, "I'm fine"); let sql = r#"SELECT 'I\"m fine'"#; assert_mysql_query_value(escaping_dialects, sql, "I\"m fine"); let sql = r"SELECT 'Testing: \0 \\ \% \_ \b \n \r \t \Z \a \h \ '"; assert_mysql_query_value( no_wildcard_exception, sql, "Testing: \0 \\ % _ \u{8} \n \r \t \u{1a} \u{7} h ", ); // check MySQL doesn't remove backslash from escaped LIKE wildcards assert_mysql_query_value( with_wildcard_exception, sql, "Testing: \0 \\ \\% \\_ \u{8} \n \r \t \u{1a} \u{7} h ", ); } #[test] fn parse_escaped_string_without_unescape() { fn assert_mysql_query_value(sql: &str, quoted: &str) { let stmt = TestedDialects::new_with_options( vec![ Box::new(MySqlDialect {}), Box::new(BigQueryDialect {}), Box::new(SnowflakeDialect {}), ], ParserOptions::new().with_unescape(false), ) .one_statement_parses_to(sql, ""); match stmt { Statement::Query(query) => match *query.body { SetExpr::Select(value) => { let expr = expr_from_projection(only(&value.projection)); assert_eq!( *expr, Expr::Value( (Value::SingleQuotedString(quoted.to_string())).with_empty_span() ) ); } _ => unreachable!(), }, _ => unreachable!(), }; } let sql = r"SELECT 'I\'m fine'"; assert_mysql_query_value(sql, r"I\'m fine"); let sql = r#"SELECT 'I''m fine'"#; assert_mysql_query_value(sql, r#"I''m fine"#); let sql = r#"SELECT 'I\"m fine'"#; assert_mysql_query_value(sql, r#"I\"m fine"#); let sql = r"SELECT 'Testing: \0 \\ \% \_ \b \n \r \t \Z \a \ '"; assert_mysql_query_value(sql, r"Testing: \0 \\ \% \_ \b \n \r \t \Z \a \ "); } #[test] fn parse_pivot_table() { let sql = concat!( "SELECT * FROM monthly_sales AS a PIVOT(", "SUM(a.amount), ", "SUM(b.amount) AS t, ", "SUM(c.amount) AS u ", "FOR a.MONTH IN (1 AS x, 'two', three AS y)) AS p (c, d) ", "ORDER BY EMPID" ); fn expected_function(table: &'static str, alias: Option<&'static str>) -> ExprWithAlias { ExprWithAlias { expr: call( "SUM", [Expr::CompoundIdentifier(vec![ Ident::new(table), Ident::new("amount"), ])], ), alias: alias.map(Ident::new), } } assert_eq!( verified_only_select(sql).from[0].relation, Pivot { table: Box::new(TableFactor::Table { name: ObjectName::from(vec![Ident::new("monthly_sales")]), alias: table_alias(true, "a"), args: None, with_hints: vec![], version: None, partitions: vec![], with_ordinality: false, json_path: None, sample: None, index_hints: vec![], }), aggregate_functions: vec![ expected_function("a", None), expected_function("b", Some("t")), expected_function("c", Some("u")), ], value_column: vec![Expr::CompoundIdentifier(vec![ Ident::new("a"), Ident::new("MONTH") ])], value_source: PivotValueSource::List(vec![ ExprWithAlias { expr: Expr::value(number("1")), alias: Some(Ident::new("x")) }, ExprWithAlias { expr: Expr::Value( (Value::SingleQuotedString("two".to_string())).with_empty_span() ), alias: None }, ExprWithAlias { expr: Expr::Identifier(Ident::new("three")), alias: Some(Ident::new("y")) }, ]), default_on_null: None, alias: Some(TableAlias { explicit: true, name: Ident { value: "p".to_string(), quote_style: None, span: Span::empty(), }, columns: vec![ TableAliasColumnDef::from_name("c"), TableAliasColumnDef::from_name("d"), ], at: None, }) } ); assert_eq!(verified_stmt(sql).to_string(), sql); // parsing should succeed with empty alias let sql_without_table_alias = concat!( "SELECT * FROM monthly_sales ", "PIVOT(SUM(a.amount) FOR a.MONTH IN ('JAN', 'FEB', 'MAR', 'APR')) AS p (c, d) ", "ORDER BY EMPID" ); assert_matches!( &verified_only_select(sql_without_table_alias).from[0].relation, Pivot { table, .. } if matches!(&**table, TableFactor::Table { alias: None, .. }) ); assert_eq!( verified_stmt(sql_without_table_alias).to_string(), sql_without_table_alias ); let multiple_value_columns_sql = concat!( "SELECT * FROM person ", "PIVOT(", "SUM(age) AS a, AVG(class) AS c ", "FOR (name, age) IN (('John', 30) AS c1, ('Mike', 40) AS c2))", ); assert_eq!( verified_only_select(multiple_value_columns_sql).from[0].relation, Pivot { table: Box::new(TableFactor::Table { name: ObjectName::from(vec![Ident::new("person")]), alias: None, args: None, with_hints: vec![], version: None, partitions: vec![], with_ordinality: false, json_path: None, sample: None, index_hints: vec![], }), aggregate_functions: vec![ ExprWithAlias { expr: call("SUM", [Expr::Identifier(Ident::new("age"))]), alias: Some(Ident::new("a")) }, ExprWithAlias { expr: call("AVG", [Expr::Identifier(Ident::new("class"))]), alias: Some(Ident::new("c")) }, ], value_column: vec![ Expr::Identifier(Ident::new("name")), Expr::Identifier(Ident::new("age")), ], value_source: PivotValueSource::List(vec![ ExprWithAlias { expr: Expr::Tuple(vec![ Expr::Value( (Value::SingleQuotedString("John".to_string())).with_empty_span() ), Expr::Value( (Value::Number("30".parse().unwrap(), false)).with_empty_span() ), ]), alias: Some(Ident::new("c1")) }, ExprWithAlias { expr: Expr::Tuple(vec![ Expr::Value( (Value::SingleQuotedString("Mike".to_string())).with_empty_span() ), Expr::Value( (Value::Number("40".parse().unwrap(), false)).with_empty_span() ), ]), alias: Some(Ident::new("c2")) }, ]), default_on_null: None, alias: None, } ); assert_eq!( verified_stmt(multiple_value_columns_sql).to_string(), multiple_value_columns_sql ); // assert optional "AS" keyword for aliases for pivot values one_statement_parses_to( "SELECT * FROM t PIVOT(SUM(1) FOR a.abc IN (1 x, 'two' y, three z))", "SELECT * FROM t PIVOT(SUM(1) FOR a.abc IN (1 AS x, 'two' AS y, three AS z))", ); // assert optional "AS" keyword for aliases for pivot aggregate function one_statement_parses_to( "SELECT * FROM t PIVOT(SUM(1) x, COUNT(42) y FOR a.abc IN (1))", "SELECT * FROM t PIVOT(SUM(1) AS x, COUNT(42) AS y FOR a.abc IN (1))", ); } #[test] fn parse_unpivot_table() { let sql = concat!( "SELECT * FROM sales AS s ", "UNPIVOT(quantity FOR quarter IN (Q1, Q2, Q3, Q4)) AS u (product, quarter, quantity)" ); let base_unpivot = Unpivot { table: Box::new(TableFactor::Table { name: ObjectName::from(vec![Ident::new("sales")]), alias: table_alias(true, "s"), args: None, with_hints: vec![], version: None, partitions: vec![], with_ordinality: false, json_path: None, sample: None, index_hints: vec![], }), null_inclusion: None, value: Expr::Identifier(Ident::new("quantity")), name: Ident::new("quarter"), columns: ["Q1", "Q2", "Q3", "Q4"] .into_iter() .map(|col| ExprWithAlias { expr: Expr::Identifier(Ident::new(col)), alias: None, }) .collect(), alias: Some(TableAlias { explicit: true, name: Ident::new("u"), columns: ["product", "quarter", "quantity"] .into_iter() .map(TableAliasColumnDef::from_name) .collect(), at: None, }), }; pretty_assertions::assert_eq!(verified_only_select(sql).from[0].relation, base_unpivot); assert_eq!(verified_stmt(sql).to_string(), sql); let sql_without_aliases = concat!( "SELECT * FROM sales ", "UNPIVOT(quantity FOR quarter IN (Q1, Q2, Q3, Q4))" ); assert_matches!( &verified_only_select(sql_without_aliases).from[0].relation, Unpivot { table, alias: None, .. } if matches!(&**table, TableFactor::Table { alias: None, .. }) ); assert_eq!( verified_stmt(sql_without_aliases).to_string(), sql_without_aliases ); let sql_unpivot_exclude_nulls = concat!( "SELECT * FROM sales AS s ", "UNPIVOT EXCLUDE NULLS (quantity FOR quarter IN (Q1, Q2, Q3, Q4)) AS u (product, quarter, quantity)" ); if let Unpivot { null_inclusion, .. } = &verified_only_select(sql_unpivot_exclude_nulls).from[0].relation { assert_eq!(*null_inclusion, Some(NullInclusion::ExcludeNulls)); } assert_eq!( verified_stmt(sql_unpivot_exclude_nulls).to_string(), sql_unpivot_exclude_nulls ); let sql_unpivot_include_nulls = concat!( "SELECT * FROM sales AS s ", "UNPIVOT INCLUDE NULLS (quantity FOR quarter IN (Q1, Q2, Q3, Q4)) AS u (product, quarter, quantity)" ); if let Unpivot { null_inclusion, .. } = &verified_only_select(sql_unpivot_include_nulls).from[0].relation { assert_eq!(*null_inclusion, Some(NullInclusion::IncludeNulls)); } assert_eq!( verified_stmt(sql_unpivot_include_nulls).to_string(), sql_unpivot_include_nulls ); let sql_unpivot_with_alias = concat!( "SELECT * FROM sales AS s ", "UNPIVOT INCLUDE NULLS ", "(quantity FOR quarter IN ", "(Q1 AS Quater1, Q2 AS Quater2, Q3 AS Quater3, Q4 AS Quater4)) ", "AS u (product, quarter, quantity)" ); if let Unpivot { value, columns, .. } = &verified_only_select(sql_unpivot_with_alias).from[0].relation { assert_eq!( *columns, vec![ ExprWithAlias { expr: Expr::Identifier(Ident::new("Q1")), alias: Some(Ident::new("Quater1")), }, ExprWithAlias { expr: Expr::Identifier(Ident::new("Q2")), alias: Some(Ident::new("Quater2")), }, ExprWithAlias { expr: Expr::Identifier(Ident::new("Q3")), alias: Some(Ident::new("Quater3")), }, ExprWithAlias { expr: Expr::Identifier(Ident::new("Q4")), alias: Some(Ident::new("Quater4")), }, ] ); assert_eq!(*value, Expr::Identifier(Ident::new("quantity"))); } assert_eq!( verified_stmt(sql_unpivot_with_alias).to_string(), sql_unpivot_with_alias ); let sql_unpivot_with_alias_and_multi_value = concat!( "SELECT * FROM sales AS s ", "UNPIVOT INCLUDE NULLS ((first_quarter, second_quarter) ", "FOR half_of_the_year IN (", "(Q1, Q2) AS H1, ", "(Q3, Q4) AS H2", "))" ); if let Unpivot { value, columns, .. } = &verified_only_select(sql_unpivot_with_alias_and_multi_value).from[0].relation { assert_eq!( *columns, vec![ ExprWithAlias { expr: Expr::Tuple(vec![ Expr::Identifier(Ident::new("Q1")), Expr::Identifier(Ident::new("Q2")), ]), alias: Some(Ident::new("H1")), }, ExprWithAlias { expr: Expr::Tuple(vec![ Expr::Identifier(Ident::new("Q3")), Expr::Identifier(Ident::new("Q4")), ]), alias: Some(Ident::new("H2")), }, ] ); assert_eq!( *value, Expr::Tuple(vec![ Expr::Identifier(Ident::new("first_quarter")), Expr::Identifier(Ident::new("second_quarter")), ]) ); } assert_eq!( verified_stmt(sql_unpivot_with_alias_and_multi_value).to_string(), sql_unpivot_with_alias_and_multi_value ); let sql_unpivot_with_alias_and_multi_value_and_qualifier = concat!( "SELECT * FROM sales AS s ", "UNPIVOT INCLUDE NULLS ((first_quarter, second_quarter) ", "FOR half_of_the_year IN (", "(sales.Q1, sales.Q2) AS H1, ", "(sales.Q3, sales.Q4) AS H2", "))" ); if let Unpivot { columns, .. } = &verified_only_select(sql_unpivot_with_alias_and_multi_value_and_qualifier).from[0].relation { assert_eq!( *columns, vec![ ExprWithAlias { expr: Expr::Tuple(vec![ Expr::CompoundIdentifier(vec![Ident::new("sales"), Ident::new("Q1"),]), Expr::CompoundIdentifier(vec![Ident::new("sales"), Ident::new("Q2"),]), ]), alias: Some(Ident::new("H1")), }, ExprWithAlias { expr: Expr::Tuple(vec![ Expr::CompoundIdentifier(vec![Ident::new("sales"), Ident::new("Q3"),]), Expr::CompoundIdentifier(vec![Ident::new("sales"), Ident::new("Q4"),]), ]), alias: Some(Ident::new("H2")), }, ] ); } assert_eq!( verified_stmt(sql_unpivot_with_alias_and_multi_value_and_qualifier).to_string(), sql_unpivot_with_alias_and_multi_value_and_qualifier ); } #[test] fn parse_select_table_with_index_hints() { let supported_dialects = all_dialects_where(|d| d.supports_table_hints()); let s = supported_dialects.verified_only_select( "SELECT * FROM t1 USE INDEX (i1) IGNORE INDEX FOR ORDER BY (i2) ORDER BY a", ); if let TableFactor::Table { index_hints, .. } = &s.from[0].relation { assert_eq!( vec![ TableIndexHints { hint_type: TableIndexHintType::Use, index_names: vec!["i1".into()], index_type: TableIndexType::Index, for_clause: None, }, TableIndexHints { hint_type: TableIndexHintType::Ignore, index_names: vec!["i2".into()], index_type: TableIndexType::Index, for_clause: Some(TableIndexHintForClause::OrderBy), }, ], *index_hints ); } else { panic!("Expected TableFactor::Table"); } supported_dialects.verified_stmt("SELECT * FROM t1 USE INDEX (i1) USE INDEX (i1, i1)"); supported_dialects.verified_stmt( "SELECT * FROM t1 USE INDEX () IGNORE INDEX (i2) USE INDEX (i1) USE INDEX (i2)", ); supported_dialects.verified_stmt("SELECT * FROM t1 FORCE INDEX FOR JOIN (i2)"); supported_dialects.verified_stmt("SELECT * FROM t1 IGNORE INDEX FOR JOIN (i2)"); supported_dialects.verified_stmt( "SELECT * FROM t USE INDEX (index1) IGNORE INDEX FOR ORDER BY (index1) IGNORE INDEX FOR GROUP BY (index1) WHERE A = B", ); // Test that dialects that don't support table hints will keep parsing the USE as table alias let sql = "SELECT * FROM T USE LIMIT 1"; let unsupported_dialects = all_dialects_where(|d| !d.supports_table_hints()); let select = unsupported_dialects .verified_only_select_with_canonical(sql, "SELECT * FROM T USE LIMIT 1"); assert_eq!( select.from, vec![TableWithJoins { relation: TableFactor::Table { name: ObjectName(vec![sqlparser::ast::ObjectNamePart::Identifier( Ident::new("T") )]), alias: table_alias(false, "USE"), args: None, with_hints: vec![], version: None, partitions: vec![], with_ordinality: false, json_path: None, sample: None, index_hints: vec![], }, joins: vec![], }] ); } #[test] fn parse_pivot_unpivot_table() { let sql = concat!( "SELECT * FROM census AS c ", "UNPIVOT(population FOR year IN (population_2000, population_2010)) AS u ", "PIVOT(sum(population) FOR year IN ('population_2000', 'population_2010')) AS p" ); pretty_assertions::assert_eq!( verified_only_select(sql).from[0].relation, Pivot { table: Box::new(Unpivot { table: Box::new(TableFactor::Table { name: ObjectName::from(vec![Ident::new("census")]), alias: table_alias(true, "c"), args: None, with_hints: vec![], version: None, partitions: vec![], with_ordinality: false, json_path: None, sample: None, index_hints: vec![], }), null_inclusion: None, value: Expr::Identifier(Ident::new("population")), name: Ident::new("year"), columns: ["population_2000", "population_2010"] .into_iter() .map(|col| ExprWithAlias { expr: Expr::Identifier(Ident::new(col)), alias: None, }) .collect(), alias: table_alias(true, "u"), }), aggregate_functions: vec![ExprWithAlias { expr: call("sum", [Expr::Identifier(Ident::new("population"))]), alias: None }], value_column: vec![Expr::Identifier(Ident::new("year"))], value_source: PivotValueSource::List(vec![ ExprWithAlias { expr: Expr::Value( (Value::SingleQuotedString("population_2000".to_string())) .with_empty_span() ), alias: None }, ExprWithAlias { expr: Expr::Value( (Value::SingleQuotedString("population_2010".to_string())) .with_empty_span() ), alias: None }, ]), default_on_null: None, alias: table_alias(true, "p"), } ); assert_eq!(verified_stmt(sql).to_string(), sql); } /// Makes a predicate that looks like ((user_id = $id) OR user_id = $2...) fn make_where_clause(num: usize) -> String { use std::fmt::Write; let mut output = "(".repeat(num - 1); for i in 0..num { if i > 0 { write!(&mut output, " OR ").unwrap(); } write!(&mut output, "user_id = {i}").unwrap(); if i < num - 1 { write!(&mut output, ")").unwrap(); } } output } #[test] fn parse_non_latin_identifiers() { let supported_dialects = TestedDialects::new(vec![ Box::new(GenericDialect {}), Box::new(DuckDbDialect {}), Box::new(PostgreSqlDialect {}), Box::new(MsSqlDialect {}), Box::new(RedshiftSqlDialect {}), Box::new(MySqlDialect {}), ]); supported_dialects.verified_stmt("SELECT a.説明 FROM test.public.inter01 AS a"); supported_dialects.verified_stmt("SELECT a.説明 FROM inter01 AS a, inter01_transactions AS b WHERE a.説明 = b.取引 GROUP BY a.説明"); supported_dialects.verified_stmt("SELECT 説明, hühnervögel, garçon, Москва, 東京 FROM inter01"); let supported_dialects = TestedDialects::new(vec![ Box::new(GenericDialect {}), Box::new(DuckDbDialect {}), Box::new(MsSqlDialect {}), ]); assert!(supported_dialects .parse_sql_statements("SELECT 💝 FROM table1") .is_err()); } #[test] fn parse_trailing_comma() { // At the moment, DuckDB is the only dialect that allows // trailing commas anywhere in the query let trailing_commas = TestedDialects::new(vec![Box::new(DuckDbDialect {})]); trailing_commas.one_statement_parses_to( "SELECT album_id, name, FROM track", "SELECT album_id, name FROM track", ); trailing_commas.one_statement_parses_to( "SELECT * FROM track ORDER BY milliseconds,", "SELECT * FROM track ORDER BY milliseconds", ); trailing_commas.one_statement_parses_to( "SELECT DISTINCT ON (album_id,) name FROM track", "SELECT DISTINCT ON (album_id) name FROM track", ); trailing_commas.one_statement_parses_to( "CREATE TABLE employees (name text, age int,)", "CREATE TABLE employees (name TEXT, age INT)", ); trailing_commas.one_statement_parses_to( "GRANT USAGE, SELECT, INSERT, ON p TO u", "GRANT USAGE, SELECT, INSERT ON p TO u", ); trailing_commas.verified_stmt("SELECT album_id, name FROM track"); trailing_commas.verified_stmt("SELECT * FROM track ORDER BY milliseconds"); trailing_commas.verified_stmt("SELECT DISTINCT ON (album_id) name FROM track"); // check quoted "from" identifier edge-case trailing_commas.one_statement_parses_to( r#"SELECT "from", FROM "from""#, r#"SELECT "from" FROM "from""#, ); trailing_commas.verified_stmt(r#"SELECT "from" FROM "from""#); // doesn't allow any trailing commas let trailing_commas = TestedDialects::new(vec![Box::new(PostgreSqlDialect {})]); assert_eq!( trailing_commas .parse_sql_statements("SELECT name, age, from employees;") .unwrap_err(), ParserError::ParserError("Expected an expression, found: from".to_string()) ); assert_eq!( trailing_commas .parse_sql_statements("REVOKE USAGE, SELECT, ON p TO u") .unwrap_err(), ParserError::ParserError("Expected: a privilege keyword, found: ON".to_string()) ); assert_eq!( trailing_commas .parse_sql_statements("CREATE TABLE employees (name text, age int,)") .unwrap_err(), ParserError::ParserError( "Expected: column name or constraint definition, found: )".to_string() ) ); let unsupported_dialects = all_dialects_where(|d| !d.supports_trailing_commas()); assert_eq!( unsupported_dialects .parse_sql_statements("SELECT * FROM track ORDER BY milliseconds,") .unwrap_err(), ParserError::ParserError("Expected: an expression, found: EOF".to_string()) ); } #[test] fn parse_projection_trailing_comma() { let trailing_commas = all_dialects_where(|d| d.supports_projection_trailing_commas()); trailing_commas.one_statement_parses_to( "SELECT album_id, name, FROM track", "SELECT album_id, name FROM track", ); trailing_commas.verified_stmt("SELECT album_id, name FROM track"); trailing_commas.verified_stmt("SELECT * FROM track ORDER BY milliseconds"); trailing_commas.verified_stmt("SELECT DISTINCT ON (album_id) name FROM track"); let unsupported_dialects = all_dialects_where(|d| { !d.supports_projection_trailing_commas() && !d.supports_trailing_commas() }); assert_eq!( unsupported_dialects .parse_sql_statements("SELECT album_id, name, FROM track") .unwrap_err(), ParserError::ParserError("Expected an expression, found: FROM".to_string()) ); } #[test] fn parse_create_type() { match verified_stmt("CREATE TYPE mytype") { Statement::CreateType { name, representation, } => { assert_eq!(name.to_string(), "mytype"); assert!(representation.is_none()); } _ => unreachable!(), } match verified_stmt("CREATE TYPE address AS (street VARCHAR(100), city TEXT COLLATE \"en_US\")") { Statement::CreateType { name, representation, } => { assert_eq!(name.to_string(), "address"); match representation { Some(UserDefinedTypeRepresentation::Composite { attributes }) => { assert_eq!(attributes.len(), 2); assert_eq!(attributes[0].name, Ident::new("street")); assert_eq!( attributes[0].data_type, DataType::Varchar(Some(CharacterLength::IntegerLength { length: 100, unit: None })) ); assert_eq!(attributes[0].collation, None); assert_eq!(attributes[1].name, Ident::new("city")); assert_eq!(attributes[1].data_type, DataType::Text); assert_eq!( attributes[1].collation.as_ref().map(|n| n.to_string()), Some("\"en_US\"".to_string()) ); } _ => unreachable!(), } } _ => unreachable!(), } verified_stmt("CREATE TYPE empty AS ()"); match verified_stmt("CREATE TYPE mood AS ENUM ('happy', 'sad')") { Statement::CreateType { name, representation, } => { assert_eq!(name.to_string(), "mood"); match representation { Some(UserDefinedTypeRepresentation::Enum { labels }) => { assert_eq!(labels.len(), 2); assert_eq!(labels[0], Ident::with_quote('\'', "happy")); assert_eq!(labels[1], Ident::with_quote('\'', "sad")); } _ => unreachable!(), } } _ => unreachable!(), } match verified_stmt("CREATE TYPE int4range AS RANGE (SUBTYPE = INTEGER, CANONICAL = fn1)") { Statement::CreateType { name, representation, } => { assert_eq!(name.to_string(), "int4range"); match representation { Some(UserDefinedTypeRepresentation::Range { options }) => { assert_eq!(options.len(), 2); assert!(matches!( options[0], UserDefinedTypeRangeOption::Subtype(DataType::Integer(_)) )); assert!(matches!( options[1], UserDefinedTypeRangeOption::Canonical(_) )); } _ => unreachable!(), } } _ => unreachable!(), } verified_stmt("CREATE TYPE textrange AS RANGE (SUBTYPE = TEXT, COLLATION = \"en_US\", MULTIRANGE_TYPE_NAME = textmultirange)"); match verified_stmt( "CREATE TYPE int4range AS RANGE (SUBTYPE = INTEGER, SUBTYPE_OPCLASS = int4_ops)", ) { Statement::CreateType { name, representation, } => { assert_eq!(name.to_string(), "int4range"); match representation { Some(UserDefinedTypeRepresentation::Range { options }) => { assert_eq!(options.len(), 2); assert!(matches!( options[0], UserDefinedTypeRangeOption::Subtype(DataType::Integer(_)) )); match &options[1] { UserDefinedTypeRangeOption::SubtypeOpClass(name) => { assert_eq!(name.to_string(), "int4_ops"); } _ => unreachable!("Expected SubtypeOpClass"), } } _ => unreachable!(), } } _ => unreachable!(), } match verified_stmt( "CREATE TYPE int4range AS RANGE (SUBTYPE = INTEGER, SUBTYPE_DIFF = int4range_subdiff)", ) { Statement::CreateType { name, representation, } => { assert_eq!(name.to_string(), "int4range"); match representation { Some(UserDefinedTypeRepresentation::Range { options }) => { assert_eq!(options.len(), 2); assert!(matches!( options[0], UserDefinedTypeRangeOption::Subtype(DataType::Integer(_)) )); match &options[1] { UserDefinedTypeRangeOption::SubtypeDiff(name) => { assert_eq!(name.to_string(), "int4range_subdiff"); } _ => unreachable!("Expected SubtypeDiff"), } } _ => unreachable!(), } } _ => unreachable!(), } match verified_stmt( "CREATE TYPE int4range AS RANGE (SUBTYPE = INTEGER, SUBTYPE_OPCLASS = int4_ops, CANONICAL = int4range_canonical, SUBTYPE_DIFF = int4range_subdiff, MULTIRANGE_TYPE_NAME = int4multirange)", ) { Statement::CreateType { name, representation, } => { assert_eq!(name.to_string(), "int4range"); match representation { Some(UserDefinedTypeRepresentation::Range { options }) => { assert_eq!(options.len(), 5); assert!(matches!( options[0], UserDefinedTypeRangeOption::Subtype(DataType::Integer(_)) )); assert!(matches!( options[1], UserDefinedTypeRangeOption::SubtypeOpClass(_) )); assert!(matches!( options[2], UserDefinedTypeRangeOption::Canonical(_) )); assert!(matches!( options[3], UserDefinedTypeRangeOption::SubtypeDiff(_) )); assert!(matches!( options[4], UserDefinedTypeRangeOption::MultirangeTypeName(_) )); } _ => unreachable!(), } } _ => unreachable!(), } match verified_stmt( "CREATE TYPE mytype (INPUT = in_fn, OUTPUT = out_fn, INTERNALLENGTH = 16, PASSEDBYVALUE)", ) { Statement::CreateType { name, representation, } => { assert_eq!(name.to_string(), "mytype"); match representation { Some(UserDefinedTypeRepresentation::SqlDefinition { options }) => { assert_eq!(options.len(), 4); assert!(matches!( options[0], UserDefinedTypeSqlDefinitionOption::Input(_) )); assert!(matches!( options[1], UserDefinedTypeSqlDefinitionOption::Output(_) )); assert!(matches!( options[2], UserDefinedTypeSqlDefinitionOption::InternalLength( UserDefinedTypeInternalLength::Fixed(16) ) )); assert!(matches!( options[3], UserDefinedTypeSqlDefinitionOption::PassedByValue )); } _ => unreachable!(), } } _ => unreachable!(), } verified_stmt("CREATE TYPE mytype (INPUT = in_fn, OUTPUT = out_fn, INTERNALLENGTH = VARIABLE, STORAGE = extended)"); // Test all storage variants for storage in ["plain", "external", "extended", "main"] { verified_stmt(&format!( "CREATE TYPE t (INPUT = f_in, OUTPUT = f_out, STORAGE = {storage})" )); } // Test all alignment variants for align in ["char", "int2", "int4", "double"] { verified_stmt(&format!( "CREATE TYPE t (INPUT = f_in, OUTPUT = f_out, ALIGNMENT = {align})" )); } // Test additional function options (PostgreSQL-specific due to ANALYZE keyword) pg_and_generic().verified_stmt("CREATE TYPE t (INPUT = f_in, OUTPUT = f_out, RECEIVE = f_recv, SEND = f_send, TYPMOD_IN = f_tmin, TYPMOD_OUT = f_tmout, ANALYZE = f_analyze, SUBSCRIPT = f_sub)"); // Test advanced options verified_stmt("CREATE TYPE t (INPUT = f_in, OUTPUT = f_out, LIKE = INT, CATEGORY = 'N', PREFERRED = true, DEFAULT = 0, ELEMENT = INTEGER, DELIMITER = ',', COLLATABLE = false)"); } #[test] fn parse_drop_type() { let sql = "DROP TYPE abc"; match verified_stmt(sql) { Statement::Drop { names, object_type, if_exists, cascade, .. } => { assert_eq_vec(&["abc"], &names); assert_eq!(ObjectType::Type, object_type); assert!(!if_exists); assert!(!cascade); } _ => unreachable!(), }; let sql = "DROP TYPE IF EXISTS def, magician, quaternion"; match verified_stmt(sql) { Statement::Drop { names, object_type, if_exists, cascade, .. } => { assert_eq_vec(&["def", "magician", "quaternion"], &names); assert_eq!(ObjectType::Type, object_type); assert!(if_exists); assert!(!cascade); } _ => unreachable!(), } let sql = "DROP TYPE IF EXISTS my_type CASCADE"; match verified_stmt(sql) { Statement::Drop { names, object_type, if_exists, cascade, .. } => { assert_eq_vec(&["my_type"], &names); assert_eq!(ObjectType::Type, object_type); assert!(if_exists); assert!(cascade); } _ => unreachable!(), } } #[test] fn parse_call() { all_dialects().verified_stmt("CALL my_procedure()"); all_dialects().verified_stmt("CALL my_procedure(1, 'a')"); pg_and_generic().verified_stmt("CALL my_procedure(1, 'a', $1)"); all_dialects().verified_stmt("CALL my_procedure"); assert_eq!( verified_stmt("CALL my_procedure('a')"), Statement::Call(Function { uses_odbc_syntax: false, parameters: FunctionArguments::None, args: FunctionArguments::List(FunctionArgumentList { duplicate_treatment: None, args: vec![FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::Value( (Value::SingleQuotedString("a".to_string())).with_empty_span() )))], clauses: vec![], }), name: ObjectName::from(vec![Ident::new("my_procedure")]), filter: None, null_treatment: None, over: None, within_group: vec![], }) ); } #[test] fn parse_execute_stored_procedure() { let expected = Statement::Execute { name: Some(ObjectName::from(vec![ Ident { value: "my_schema".to_string(), quote_style: None, span: Span::empty(), }, Ident { value: "my_stored_procedure".to_string(), quote_style: None, span: Span::empty(), }, ])), parameters: vec![ Expr::Value((Value::NationalStringLiteral("param1".to_string())).with_empty_span()), Expr::Value((Value::NationalStringLiteral("param2".to_string())).with_empty_span()), ], has_parentheses: false, immediate: false, using: vec![], into: vec![], output: false, default: false, }; assert_eq!( // Microsoft SQL Server does not use parentheses around arguments for EXECUTE ms_and_generic() .verified_stmt("EXECUTE my_schema.my_stored_procedure N'param1', N'param2'"), expected ); assert_eq!( ms_and_generic().one_statement_parses_to( "EXEC my_schema.my_stored_procedure N'param1', N'param2';", "EXECUTE my_schema.my_stored_procedure N'param1', N'param2'", ), expected ); match ms_and_generic().verified_stmt("EXECUTE dbo.proc1 @ReturnVal = @X OUTPUT") { Statement::Execute { output, .. } => { assert!(output); } _ => unreachable!(), } match ms_and_generic().verified_stmt("EXECUTE dbo.proc1 DEFAULT") { Statement::Execute { default, .. } => { assert!(default); } _ => unreachable!(), } // Parenthesised form is dynamic SQL; the expression ends up in parameters. ms_and_generic().one_statement_parses_to("EXEC ('name')", "EXECUTE ('name')"); } #[test] fn parse_execute_immediate() { let dialects = all_dialects_where(|d| d.supports_execute_immediate()); let expected = Statement::Execute { parameters: vec![Expr::Value( (Value::SingleQuotedString("SELECT 1".to_string())).with_empty_span(), )], immediate: true, using: vec![ExprWithAlias { expr: Expr::value(number("1")), alias: Some(Ident::new("b")), }], into: vec![Ident::new("a")], name: None, has_parentheses: false, output: false, default: false, }; let stmt = dialects.verified_stmt("EXECUTE IMMEDIATE 'SELECT 1' INTO a USING 1 AS b"); assert_eq!(expected, stmt); dialects.verified_stmt("EXECUTE IMMEDIATE 'SELECT 1' INTO a, b USING 1 AS x, y"); dialects.verified_stmt("EXECUTE IMMEDIATE 'SELECT 1' USING 1 AS x, y"); dialects.verified_stmt("EXECUTE IMMEDIATE 'SELECT 1' INTO a, b"); dialects.verified_stmt("EXECUTE IMMEDIATE 'SELECT 1'"); dialects.verified_stmt("EXECUTE 'SELECT 1'"); assert_eq!( ParserError::ParserError("Expected: identifier, found: ,".to_string()), dialects .parse_sql_statements("EXECUTE IMMEDIATE 'SELECT 1' USING 1 AS, y") .unwrap_err() ); } #[test] fn parse_create_table_collate() { all_dialects().verified_stmt("CREATE TABLE tbl (foo INT, bar TEXT COLLATE \"de_DE\")"); // check ordering is preserved all_dialects().verified_stmt( "CREATE TABLE tbl (foo INT, bar TEXT CHARACTER SET utf8mb4 COLLATE \"de_DE\")", ); all_dialects().verified_stmt( "CREATE TABLE tbl (foo INT, bar TEXT COLLATE \"de_DE\" CHARACTER SET utf8mb4)", ); } #[test] fn parse_binary_operators_without_whitespace() { // x + y all_dialects().one_statement_parses_to( "SELECT field+1000 FROM tbl1", "SELECT field + 1000 FROM tbl1", ); all_dialects().one_statement_parses_to( "SELECT tbl1.field+tbl2.field FROM tbl1 JOIN tbl2 ON tbl1.id = tbl2.entity_id", "SELECT tbl1.field + tbl2.field FROM tbl1 JOIN tbl2 ON tbl1.id = tbl2.entity_id", ); // x - y all_dialects().one_statement_parses_to( "SELECT field-1000 FROM tbl1", "SELECT field - 1000 FROM tbl1", ); all_dialects().one_statement_parses_to( "SELECT tbl1.field-tbl2.field FROM tbl1 JOIN tbl2 ON tbl1.id = tbl2.entity_id", "SELECT tbl1.field - tbl2.field FROM tbl1 JOIN tbl2 ON tbl1.id = tbl2.entity_id", ); // x * y all_dialects().one_statement_parses_to( "SELECT field*1000 FROM tbl1", "SELECT field * 1000 FROM tbl1", ); all_dialects().one_statement_parses_to( "SELECT tbl1.field*tbl2.field FROM tbl1 JOIN tbl2 ON tbl1.id = tbl2.entity_id", "SELECT tbl1.field * tbl2.field FROM tbl1 JOIN tbl2 ON tbl1.id = tbl2.entity_id", ); // x / y all_dialects().one_statement_parses_to( "SELECT field/1000 FROM tbl1", "SELECT field / 1000 FROM tbl1", ); all_dialects().one_statement_parses_to( "SELECT tbl1.field/tbl2.field FROM tbl1 JOIN tbl2 ON tbl1.id = tbl2.entity_id", "SELECT tbl1.field / tbl2.field FROM tbl1 JOIN tbl2 ON tbl1.id = tbl2.entity_id", ); // x % y all_dialects().one_statement_parses_to( "SELECT field%1000 FROM tbl1", "SELECT field % 1000 FROM tbl1", ); all_dialects().one_statement_parses_to( "SELECT tbl1.field%tbl2.field FROM tbl1 JOIN tbl2 ON tbl1.id = tbl2.entity_id", "SELECT tbl1.field % tbl2.field FROM tbl1 JOIN tbl2 ON tbl1.id = tbl2.entity_id", ); } #[test] fn parse_unload() { let unload = verified_stmt("UNLOAD(SELECT cola FROM tab) TO 's3://...' WITH (format = 'AVRO')"); assert_eq!( unload, Statement::Unload { query: Some(Box::new(Query { body: Box::new(SetExpr::Select(Box::new(Select { select_token: AttachedToken::empty(), optimizer_hints: vec![], distinct: None, select_modifiers: None, top: None, top_before_distinct: false, projection: vec![UnnamedExpr(Expr::Identifier(Ident::new("cola"))),], exclude: None, into: None, from: vec![TableWithJoins { relation: table_from_name(ObjectName::from(vec![Ident::new("tab")])), joins: vec![], }], lateral_views: vec![], prewhere: None, selection: None, group_by: GroupByExpr::Expressions(vec![], vec![]), cluster_by: vec![], distribute_by: vec![], sort_by: vec![], having: None, named_window: vec![], window_before_qualify: false, qualify: None, value_table_mode: None, connect_by: vec![], flavor: SelectFlavor::Standard, }))), with: None, limit_clause: None, fetch: None, locks: vec![], for_clause: None, order_by: None, settings: None, format_clause: None, pipe_operators: vec![], })), to: Ident { value: "s3://...".to_string(), quote_style: Some('\''), span: Span::empty(), }, with: vec![SqlOption::KeyValue { key: Ident { value: "format".to_string(), quote_style: None, span: Span::empty(), }, value: Expr::Value( (Value::SingleQuotedString("AVRO".to_string())).with_empty_span() ) }], query_text: None, auth: None, options: vec![], } ); one_statement_parses_to( concat!( "UNLOAD('SELECT 1') ", "TO 's3://...' ", "IAM_ROLE 'arn:aws:iam::123456789:role/role1' ", "FORMAT AS CSV ", "FORMAT AS PARQUET ", "FORMAT AS JSON ", "MAXFILESIZE AS 10 MB ", "ROWGROUPSIZE AS 10 MB ", "PARALLEL ON ", "PARALLEL OFF ", "REGION AS 'us-east-1'" ), concat!( "UNLOAD('SELECT 1') ", "TO 's3://...' ", "IAM_ROLE 'arn:aws:iam::123456789:role/role1' ", "CSV ", "PARQUET ", "JSON ", "MAXFILESIZE 10 MB ", "ROWGROUPSIZE 10 MB ", "PARALLEL TRUE ", "PARALLEL FALSE ", "REGION 'us-east-1'" ), ); verified_stmt(concat!( "UNLOAD('SELECT 1') ", "TO 's3://...' ", "IAM_ROLE 'arn:aws:iam::123456789:role/role1' ", "PARTITION BY (c1, c2, c3)", )); verified_stmt(concat!( "UNLOAD('SELECT 1') ", "TO 's3://...' ", "IAM_ROLE 'arn:aws:iam::123456789:role/role1' ", "PARTITION BY (c1, c2, c3) INCLUDE", )); verified_stmt(concat!( "UNLOAD('SELECT 1') ", "TO 's3://...' ", "IAM_ROLE 'arn:aws:iam::123456789:role/role1' ", "PARTITION BY (c1, c2, c3) INCLUDE ", "MANIFEST" )); verified_stmt(concat!( "UNLOAD('SELECT 1') ", "TO 's3://...' ", "IAM_ROLE 'arn:aws:iam::123456789:role/role1' ", "PARTITION BY (c1, c2, c3) INCLUDE ", "MANIFEST VERBOSE" )); verified_stmt(concat!( "UNLOAD('SELECT 1') ", "TO 's3://...' ", "IAM_ROLE 'arn:aws:iam::123456789:role/role1' ", "PARTITION BY (c1, c2, c3) INCLUDE ", "MANIFEST VERBOSE ", "HEADER ", "FIXEDWIDTH 'col1:1,col2:2' ", "ENCRYPTED" )); verified_stmt(concat!( "UNLOAD('SELECT 1') ", "TO 's3://...' ", "IAM_ROLE 'arn:aws:iam::123456789:role/role1' ", "PARTITION BY (c1, c2, c3) INCLUDE ", "MANIFEST VERBOSE ", "HEADER ", "FIXEDWIDTH 'col1:1,col2:2' ", "ENCRYPTED AUTO" )); verified_stmt(concat!( "UNLOAD('SELECT 1') ", "TO 's3://...' ", "IAM_ROLE 'arn:aws:iam::123456789:role/role1' ", "PARTITION BY (c1, c2, c3) INCLUDE ", "MANIFEST VERBOSE ", "HEADER ", "FIXEDWIDTH 'col1:1,col2:2' ", "ENCRYPTED AUTO ", "BZIP2 ", "GZIP ", "ZSTD ", "ADDQUOTES ", "NULL 'nil' ", "ESCAPE ", "ALLOWOVERWRITE ", "CLEANPATH ", "PARALLEL ", "PARALLEL TRUE ", "PARALLEL FALSE ", "MAXFILESIZE 10 ", "MAXFILESIZE 10 MB ", "MAXFILESIZE 10 GB ", "ROWGROUPSIZE 10 ", "ROWGROUPSIZE 10 MB ", "ROWGROUPSIZE 10 GB ", "REGION 'us-east-1' ", "EXTENSION 'ext1'" )); } #[test] fn test_savepoint() { match verified_stmt("SAVEPOINT test1") { Statement::Savepoint { name } => { assert_eq!(Ident::new("test1"), name); } _ => unreachable!(), } } #[test] fn test_release_savepoint() { match verified_stmt("RELEASE SAVEPOINT test1") { Statement::ReleaseSavepoint { name } => { assert_eq!(Ident::new("test1"), name); } _ => unreachable!(), } one_statement_parses_to("RELEASE test1", "RELEASE SAVEPOINT test1"); } #[test] fn test_comment_hash_syntax() { let dialects = TestedDialects::new(vec![ Box::new(BigQueryDialect {}), Box::new(SnowflakeDialect {}), Box::new(MySqlDialect {}), Box::new(HiveDialect {}), ]); let sql = r#" # comment SELECT a, b, c # , d, e FROM T ####### comment ################# WHERE true # comment "#; let canonical = "SELECT a, b, c FROM T WHERE true"; dialects.verified_only_select_with_canonical(sql, canonical); } #[test] fn test_parse_inline_comment() { let sql = "CREATE TABLE t0 (id INT COMMENT 'comment without equal') COMMENT = 'comment with equal'"; // Hive dialect doesn't support `=` in table comment, please refer: // [Hive](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+DDL#LanguageManualDDL-CreateTable) match all_dialects_except(|d| d.is::()).verified_stmt(sql) { Statement::CreateTable(CreateTable { columns, table_options, .. }) => { assert_eq!( columns, vec![ColumnDef { name: Ident::new("id".to_string()), data_type: DataType::Int(None), options: vec![ColumnOptionDef { name: None, option: Comment("comment without equal".to_string()), }] }] ); assert_eq!( table_options, CreateTableOptions::Plain(vec![SqlOption::Comment(CommentDef::WithEq( "comment with equal".to_string() ))]) ); } _ => unreachable!(), } } #[test] fn test_buffer_reuse() { let d = GenericDialect {}; let q = "INSERT INTO customer WITH foo AS (SELECT 1) SELECT * FROM foo UNION VALUES (1)"; let mut buf = Vec::new(); Tokenizer::new(&d, q) .tokenize_with_location_into_buf(&mut buf) .unwrap(); let mut p = Parser::new(&d).with_tokens_with_locations(buf); p.parse_statements().unwrap(); let _ = p.into_tokens(); } #[test] fn parse_map_access_expr() { let sql = "users[-1][safe_offset(2)]"; let dialects = TestedDialects::new(vec![ Box::new(BigQueryDialect {}), Box::new(ClickHouseDialect {}), ]); let expr = dialects.verified_expr(sql); let expected = Expr::CompoundFieldAccess { root: Box::new(Expr::Identifier(Ident::with_span( Span::new(Location::of(1, 1), Location::of(1, 6)), "users", ))), access_chain: vec![ AccessExpr::Subscript(Subscript::Index { index: Expr::UnaryOp { op: UnaryOperator::Minus, expr: Expr::value(number("1")).into(), }, }), AccessExpr::Subscript(Subscript::Index { index: Expr::Function(Function { name: ObjectName::from(vec![Ident::with_span( Span::new(Location::of(1, 11), Location::of(1, 22)), "safe_offset", )]), parameters: FunctionArguments::None, args: FunctionArguments::List(FunctionArgumentList { duplicate_treatment: None, args: vec![FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::Value( (number("2")).with_empty_span(), )))], clauses: vec![], }), filter: None, null_treatment: None, over: None, within_group: vec![], uses_odbc_syntax: false, }), }), ], }; assert_eq!(expr, expected); for sql in ["users[1]", "a[array_length(b) - 1 + 2][c + 3][d * 4]"] { let _ = dialects.verified_expr(sql); } } #[test] fn parse_connect_by() { let dialects = all_dialects_where(|d| d.supports_connect_by()); let connect_by_1 = concat!( "SELECT employee_id, manager_id, title FROM employees ", "START WITH title = 'president' ", "CONNECT BY manager_id = PRIOR employee_id ", "ORDER BY employee_id" ); assert_eq!( dialects.verified_only_select(connect_by_1), Select { select_token: AttachedToken::empty(), optimizer_hints: vec![], distinct: None, select_modifiers: None, top: None, top_before_distinct: false, projection: vec![ SelectItem::UnnamedExpr(Expr::Identifier(Ident::new("employee_id"))), SelectItem::UnnamedExpr(Expr::Identifier(Ident::new("manager_id"))), SelectItem::UnnamedExpr(Expr::Identifier(Ident::new("title"))), ], exclude: None, from: vec![TableWithJoins { relation: table_from_name(ObjectName::from(vec![Ident::new("employees")])), joins: vec![], }], into: None, lateral_views: vec![], prewhere: None, selection: None, group_by: GroupByExpr::Expressions(vec![], vec![]), cluster_by: vec![], distribute_by: vec![], sort_by: vec![], having: None, named_window: vec![], qualify: None, window_before_qualify: false, value_table_mode: None, connect_by: vec![ ConnectByKind::StartWith { start_token: AttachedToken::empty(), condition: Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("title"))), op: BinaryOperator::Eq, right: Box::new(Expr::Value( Value::SingleQuotedString("president".to_owned()).with_empty_span(), )), } .into() }, ConnectByKind::ConnectBy { connect_token: AttachedToken::empty(), nocycle: false, relationships: vec![Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("manager_id"))), op: BinaryOperator::Eq, right: Box::new(Expr::Prior(Box::new(Expr::Identifier(Ident::new( "employee_id", ))))), }], } ], flavor: SelectFlavor::Standard, } ); // CONNECT BY can come before START WITH let connect_by_2 = concat!( "SELECT employee_id, manager_id, title FROM employees ", "CONNECT BY manager_id = PRIOR employee_id ", "START WITH title = 'president' ", "ORDER BY employee_id" ); assert_eq!( dialects.verified_only_select(connect_by_2), Select { select_token: AttachedToken::empty(), optimizer_hints: vec![], distinct: None, select_modifiers: None, top: None, top_before_distinct: false, projection: vec![ SelectItem::UnnamedExpr(Expr::Identifier(Ident::new("employee_id"))), SelectItem::UnnamedExpr(Expr::Identifier(Ident::new("manager_id"))), SelectItem::UnnamedExpr(Expr::Identifier(Ident::new("title"))), ], exclude: None, from: vec![TableWithJoins { relation: table_from_name(ObjectName::from(vec![Ident::new("employees")])), joins: vec![], }], into: None, lateral_views: vec![], prewhere: None, selection: None, group_by: GroupByExpr::Expressions(vec![], vec![]), cluster_by: vec![], distribute_by: vec![], sort_by: vec![], having: None, named_window: vec![], qualify: None, window_before_qualify: false, value_table_mode: None, connect_by: vec![ ConnectByKind::ConnectBy { connect_token: AttachedToken::empty(), nocycle: false, relationships: vec![Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("manager_id"))), op: BinaryOperator::Eq, right: Box::new(Expr::Prior(Box::new(Expr::Identifier(Ident::new( "employee_id", ))))), }], }, ConnectByKind::StartWith { start_token: AttachedToken::empty(), condition: Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("title"))), op: BinaryOperator::Eq, right: Box::new(Expr::Value( Value::SingleQuotedString("president".to_owned()).with_empty_span(), )), } .into() }, ], flavor: SelectFlavor::Standard, } ); // WHERE must come before CONNECT BY let connect_by_3 = concat!( "SELECT employee_id, manager_id, title FROM employees ", "WHERE employee_id <> 42 ", "START WITH title = 'president' ", "CONNECT BY manager_id = PRIOR employee_id ", "ORDER BY employee_id" ); assert_eq!( dialects.verified_only_select(connect_by_3), Select { select_token: AttachedToken::empty(), optimizer_hints: vec![], distinct: None, select_modifiers: None, top: None, top_before_distinct: false, projection: vec![ SelectItem::UnnamedExpr(Expr::Identifier(Ident::new("employee_id"))), SelectItem::UnnamedExpr(Expr::Identifier(Ident::new("manager_id"))), SelectItem::UnnamedExpr(Expr::Identifier(Ident::new("title"))), ], exclude: None, from: vec![TableWithJoins { relation: table_from_name(ObjectName::from(vec![Ident::new("employees")])), joins: vec![], }], into: None, lateral_views: vec![], prewhere: None, selection: Some(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("employee_id"))), op: BinaryOperator::NotEq, right: Box::new(Expr::value(number("42"))), }), group_by: GroupByExpr::Expressions(vec![], vec![]), cluster_by: vec![], distribute_by: vec![], sort_by: vec![], having: None, named_window: vec![], qualify: None, window_before_qualify: false, value_table_mode: None, connect_by: vec![ ConnectByKind::StartWith { start_token: AttachedToken::empty(), condition: Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("title"))), op: BinaryOperator::Eq, right: Box::new(Expr::Value( (Value::SingleQuotedString("president".to_owned(),)).with_empty_span() )), } .into() }, ConnectByKind::ConnectBy { connect_token: AttachedToken::empty(), nocycle: false, relationships: vec![Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("manager_id"))), op: BinaryOperator::Eq, right: Box::new(Expr::Prior(Box::new(Expr::Identifier(Ident::new( "employee_id", ))))), }], } ], flavor: SelectFlavor::Standard, } ); let connect_by_4 = concat!( "SELECT employee_id, manager_id, title FROM employees ", "START WITH title = 'president' ", "CONNECT BY manager_id = PRIOR employee_id ", "WHERE employee_id <> 42 ", "ORDER BY employee_id" ); dialects .parse_sql_statements(connect_by_4) .expect_err("should have failed"); // PRIOR expressions are only valid within a CONNECT BY, and the the token // `prior` is valid as an identifier anywhere else. assert_eq!( all_dialects() .verified_only_select("SELECT prior FROM some_table") .projection, vec![SelectItem::UnnamedExpr(Expr::Identifier(Ident::new( "prior" )))] ); // no START WITH and NOCYCLE let connect_by_5 = "SELECT child, parent FROM t CONNECT BY NOCYCLE parent = PRIOR child"; assert_eq!( dialects.verified_only_select(connect_by_5), Select { select_token: AttachedToken::empty(), optimizer_hints: vec![], distinct: None, select_modifiers: None, top: None, top_before_distinct: false, projection: vec![ SelectItem::UnnamedExpr(Expr::Identifier(Ident::new("child"))), SelectItem::UnnamedExpr(Expr::Identifier(Ident::new("parent"))), ], exclude: None, from: vec![TableWithJoins { relation: table_from_name(ObjectName::from(vec![Ident::new("t")])), joins: vec![], }], into: None, lateral_views: vec![], prewhere: None, selection: None, group_by: GroupByExpr::Expressions(vec![], vec![]), cluster_by: vec![], distribute_by: vec![], sort_by: vec![], having: None, named_window: vec![], qualify: None, window_before_qualify: false, value_table_mode: None, connect_by: vec![ConnectByKind::ConnectBy { connect_token: AttachedToken::empty(), nocycle: true, relationships: vec![Expr::BinaryOp { left: Expr::Identifier(Ident::new("parent")).into(), op: BinaryOperator::Eq, right: Expr::Prior(Expr::Identifier(Ident::new("child")).into()).into(), }], }], flavor: SelectFlavor::Standard, } ); // CONNECT BY after WHERE and before GROUP BY dialects.verified_only_select("SELECT 0 FROM t WHERE 1 = 1 CONNECT BY 2 = 2 GROUP BY 3"); dialects.verified_only_select( "SELECT 0 FROM t WHERE 1 = 1 START WITH 'a' = 'a' CONNECT BY 2 = 2 GROUP BY 3", ); dialects.verified_only_select( "SELECT 0 FROM t WHERE 1 = 1 CONNECT BY 2 = 2 START WITH 'a' = 'a' GROUP BY 3", ); } #[test] fn test_selective_aggregation() { let testing_dialects = all_dialects_where(|d| d.supports_filter_during_aggregation()); let expected_dialects: Vec> = vec![ Box::new(PostgreSqlDialect {}), Box::new(DatabricksDialect {}), Box::new(HiveDialect {}), Box::new(SQLiteDialect {}), Box::new(DuckDbDialect {}), Box::new(GenericDialect {}), ]; assert_eq!(testing_dialects.dialects.len(), expected_dialects.len()); expected_dialects .into_iter() .for_each(|d| assert!(d.supports_filter_during_aggregation())); let sql = concat!( "SELECT ", "ARRAY_AGG(name) FILTER (WHERE name IS NOT NULL), ", "ARRAY_AGG(name) FILTER (WHERE name LIKE 'a%') AS agg2 ", "FROM region" ); assert_eq!( testing_dialects.verified_only_select(sql).projection, vec![ SelectItem::UnnamedExpr(Expr::Function(Function { name: ObjectName::from(vec![Ident::new("ARRAY_AGG")]), uses_odbc_syntax: false, parameters: FunctionArguments::None, args: FunctionArguments::List(FunctionArgumentList { duplicate_treatment: None, args: vec![FunctionArg::Unnamed(FunctionArgExpr::Expr( Expr::Identifier(Ident::new("name")) ))], clauses: vec![], }), filter: Some(Box::new(Expr::IsNotNull(Box::new(Expr::Identifier( Ident::new("name") ))))), over: None, within_group: vec![], null_treatment: None })), SelectItem::ExprWithAlias { expr: Expr::Function(Function { name: ObjectName::from(vec![Ident::new("ARRAY_AGG")]), uses_odbc_syntax: false, parameters: FunctionArguments::None, args: FunctionArguments::List(FunctionArgumentList { duplicate_treatment: None, args: vec![FunctionArg::Unnamed(FunctionArgExpr::Expr( Expr::Identifier(Ident::new("name")) ))], clauses: vec![], }), filter: Some(Box::new(Expr::Like { negated: false, expr: Box::new(Expr::Identifier(Ident::new("name"))), pattern: Box::new(Expr::Value( (Value::SingleQuotedString("a%".to_owned())).with_empty_span() )), escape_char: None, any: false, })), null_treatment: None, over: None, within_group: vec![] }), alias: Ident::new("agg2") }, ] ) } #[test] fn test_group_by_grouping_sets() { let sql = concat!( "SELECT city, car_model, sum(quantity) AS sum ", "FROM dealer ", "GROUP BY GROUPING SETS ((city, car_model), (city), (car_model), ()) ", "ORDER BY city", ); assert_eq!( all_dialects_where(|d| d.supports_group_by_expr()) .verified_only_select(sql) .group_by, GroupByExpr::Expressions( vec![Expr::GroupingSets(vec![ vec![ Expr::Identifier(Ident::new("city")), Expr::Identifier(Ident::new("car_model")) ], vec![Expr::Identifier(Ident::new("city")),], vec![Expr::Identifier(Ident::new("car_model"))], vec![] ])], vec![] ) ); } #[test] fn test_group_by_grouping_sets_bare_columns() { all_dialects_where(|d| d.supports_group_by_expr()).one_statement_parses_to( "SELECT a, b FROM t GROUP BY GROUPING SETS (a, b, c)", "SELECT a, b FROM t GROUP BY GROUPING SETS ((a), (b), (c))", ); all_dialects_where(|d| d.supports_group_by_expr()).one_statement_parses_to( "SELECT a, b FROM t GROUP BY GROUPING SETS ((a, b), c)", "SELECT a, b FROM t GROUP BY GROUPING SETS ((a, b), (c))", ); } #[test] fn test_xmltable() { all_dialects() .verified_only_select("SELECT * FROM XMLTABLE('/root' PASSING data COLUMNS element TEXT)"); // Minimal meaningful working example: returns a single row with a single column named y containing the value z all_dialects().verified_only_select( "SELECT y FROM XMLTABLE('/X' PASSING 'z' COLUMNS y TEXT)", ); // Test using subqueries all_dialects().verified_only_select("SELECT y FROM XMLTABLE((SELECT '/X') PASSING (SELECT CAST('z' AS xml)) COLUMNS y TEXT PATH (SELECT 'y'))"); // NOT NULL all_dialects().verified_only_select( "SELECT y FROM XMLTABLE('/X' PASSING '' COLUMNS y TEXT NOT NULL)", ); all_dialects().verified_only_select("SELECT * FROM XMLTABLE('/root/row' PASSING xmldata COLUMNS id INT PATH '@id', name TEXT PATH 'name/text()', value FLOAT PATH 'value')"); all_dialects().verified_only_select("SELECT * FROM XMLTABLE('//ROWS/ROW' PASSING data COLUMNS row_num FOR ORDINALITY, id INT PATH '@id', name TEXT PATH 'NAME' DEFAULT 'unnamed')"); // Example from https://www.postgresql.org/docs/15/functions-xml.html#FUNCTIONS-XML-PROCESSING all_dialects().verified_only_select( "SELECT xmltable.* FROM xmldata, XMLTABLE('//ROWS/ROW' PASSING data COLUMNS id INT PATH '@id', ordinality FOR ORDINALITY, \"COUNTRY_NAME\" TEXT, country_id TEXT PATH 'COUNTRY_ID', size_sq_km FLOAT PATH 'SIZE[@unit = \"sq_km\"]', size_other TEXT PATH 'concat(SIZE[@unit!=\"sq_km\"], \" \", SIZE[@unit!=\"sq_km\"]/@unit)', premier_name TEXT PATH 'PREMIER_NAME' DEFAULT 'not specified')" ); // Example from DB2 docs without explicit PASSING clause: https://www.ibm.com/docs/en/db2/12.1.0?topic=xquery-simple-column-name-passing-xmlexists-xmlquery-xmltable all_dialects().verified_only_select( "SELECT X.* FROM T1, XMLTABLE('$CUSTLIST/customers/customerinfo' COLUMNS \"Cid\" BIGINT PATH '@Cid', \"Info\" XML PATH 'document{.}', \"History\" XML PATH 'NULL') AS X" ); // Example from PostgreSQL with XMLNAMESPACES all_dialects().verified_only_select( "SELECT xmltable.* FROM XMLTABLE(XMLNAMESPACES('http://example.com/myns' AS x, 'http://example.com/b' AS \"B\"), '/x:example/x:item' PASSING (SELECT data FROM xmldata) COLUMNS foo INT PATH '@foo', bar INT PATH '@B:bar')" ); } #[test] fn test_match_recognize() { use MatchRecognizePattern::*; use MatchRecognizeSymbol::*; use RepetitionQuantifier::*; let table = table_from_name(ObjectName::from(vec![Ident::new("my_table")])); fn check(options: &str, expect: TableFactor) { let select = all_dialects_where(|d| d.supports_match_recognize()).verified_only_select( &format!("SELECT * FROM my_table MATCH_RECOGNIZE({options})"), ); assert_eq!(&select.from[0].relation, &expect); } check( concat!( "PARTITION BY company ", "ORDER BY price_date ", "MEASURES ", "MATCH_NUMBER() AS match_number, ", "FIRST(price_date) AS start_date, ", "LAST(price_date) AS end_date ", "ONE ROW PER MATCH ", "AFTER MATCH SKIP TO LAST row_with_price_increase ", "PATTERN (row_before_decrease row_with_price_decrease+ row_with_price_increase+) ", "DEFINE ", "row_with_price_decrease AS price < LAG(price), ", "row_with_price_increase AS price > LAG(price)" ), TableFactor::MatchRecognize { table: Box::new(table), partition_by: vec![Expr::Identifier(Ident::new("company"))], order_by: vec![OrderByExpr { expr: Expr::Identifier(Ident::new("price_date")), options: OrderByOptions { asc: None, nulls_first: None, }, with_fill: None, }], measures: vec![ Measure { expr: call("MATCH_NUMBER", []), alias: Ident::new("match_number"), }, Measure { expr: call("FIRST", [Expr::Identifier(Ident::new("price_date"))]), alias: Ident::new("start_date"), }, Measure { expr: call("LAST", [Expr::Identifier(Ident::new("price_date"))]), alias: Ident::new("end_date"), }, ], rows_per_match: Some(RowsPerMatch::OneRow), after_match_skip: Some(AfterMatchSkip::ToLast(Ident::new( "row_with_price_increase", ))), pattern: Concat(vec![ Symbol(Named(Ident::new("row_before_decrease"))), Repetition( Box::new(Symbol(Named(Ident::new("row_with_price_decrease")))), OneOrMore, ), Repetition( Box::new(Symbol(Named(Ident::new("row_with_price_increase")))), OneOrMore, ), ]), symbols: vec![ SymbolDefinition { symbol: Ident::new("row_with_price_decrease"), definition: Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("price"))), op: BinaryOperator::Lt, right: Box::new(call("LAG", [Expr::Identifier(Ident::new("price"))])), }, }, SymbolDefinition { symbol: Ident::new("row_with_price_increase"), definition: Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("price"))), op: BinaryOperator::Gt, right: Box::new(call("LAG", [Expr::Identifier(Ident::new("price"))])), }, }, ], alias: None, }, ); #[rustfmt::skip] let examples = [ concat!( "SELECT * ", "FROM login_attempts ", "MATCH_RECOGNIZE(", "PARTITION BY user_id ", "ORDER BY timestamp ", "PATTERN (failed_attempt{3,}) ", "DEFINE ", "failed_attempt AS status = 'failure'", ")", ), concat!( "SELECT * ", "FROM stock_transactions ", "MATCH_RECOGNIZE(", "PARTITION BY symbol ", "ORDER BY timestamp ", "MEASURES ", "FIRST(price) AS start_price, ", "LAST(price) AS end_price, ", "MATCH_NUMBER() AS match_num ", "ALL ROWS PER MATCH ", "PATTERN (STRT UP+) ", "DEFINE ", "UP AS price > PREV(price)", ")", ), concat!( "SELECT * ", "FROM event_log ", "MATCH_RECOGNIZE(", "MEASURES ", "FIRST(event_type) AS start_event, ", "LAST(event_type) AS end_event, ", "COUNT(*) AS error_count ", "ALL ROWS PER MATCH ", "PATTERN (STRT ERROR+ END) ", "DEFINE ", "STRT AS event_type = 'START', ", "ERROR AS event_type = 'ERROR', ", "END AS event_type = 'END'", ")", ) ]; for sql in examples { all_dialects_where(|d| d.supports_match_recognize()).verified_query(sql); } } #[test] fn test_match_recognize_patterns() { use MatchRecognizePattern::*; use MatchRecognizeSymbol::*; use RepetitionQuantifier::*; fn check(pattern: &str, expect: MatchRecognizePattern) { let select = all_dialects_where(|d| d.supports_match_recognize()).verified_only_select(&format!( "SELECT * FROM my_table MATCH_RECOGNIZE(PATTERN ({pattern}) DEFINE DUMMY AS 1 = 1)" // "select * from my_table match_recognize (" )); let TableFactor::MatchRecognize { pattern: actual, .. } = &select.from[0].relation else { panic!("expected match_recognize table factor"); }; assert_eq!(actual, &expect); } // just a symbol check("FOO", Symbol(Named(Ident::new("FOO")))); // just a symbol check( "^ FOO $", Concat(vec![ Symbol(Start), Symbol(Named(Ident::new("FOO"))), Symbol(End), ]), ); // exclusion check("{- FOO -}", Exclude(Named(Ident::new("FOO")))); check( "PERMUTE(A, B, C)", Permute(vec![ Named(Ident::new("A")), Named(Ident::new("B")), Named(Ident::new("C")), ]), ); // various identifiers check( "FOO | \"BAR\" | baz42", Alternation(vec![ Symbol(Named(Ident::new("FOO"))), Symbol(Named(Ident::with_quote('"', "BAR"))), Symbol(Named(Ident::new("baz42"))), ]), ); // concatenated basic quantifiers check( "S1* S2+ S3?", Concat(vec![ Repetition(Box::new(Symbol(Named(Ident::new("S1")))), ZeroOrMore), Repetition(Box::new(Symbol(Named(Ident::new("S2")))), OneOrMore), Repetition(Box::new(Symbol(Named(Ident::new("S3")))), AtMostOne), ]), ); // double repetition check( "S2*?", Repetition( Box::new(Repetition( Box::new(Symbol(Named(Ident::new("S2")))), ZeroOrMore, )), AtMostOne, ), ); // range quantifiers in an alternation check( "S1{1} | S2{2,3} | S3{4,} | S4{,5}", Alternation(vec![ Repetition(Box::new(Symbol(Named(Ident::new("S1")))), Exactly(1)), Repetition(Box::new(Symbol(Named(Ident::new("S2")))), Range(2, 3)), Repetition(Box::new(Symbol(Named(Ident::new("S3")))), AtLeast(4)), Repetition(Box::new(Symbol(Named(Ident::new("S4")))), AtMost(5)), ]), ); // grouping case 1 check( "S1 ( S2 )", Concat(vec![ Symbol(Named(Ident::new("S1"))), Group(Box::new(Symbol(Named(Ident::new("S2"))))), ]), ); // grouping case 2 check( "( {- S3 -} S4 )+", Repetition( Box::new(Group(Box::new(Concat(vec![ Exclude(Named(Ident::new("S3"))), Symbol(Named(Ident::new("S4"))), ])))), OneOrMore, ), ); // the grand finale (example taken from snowflake docs) check( "^ S1 S2*? ( {- S3 -} S4 )+ | PERMUTE(S1, S2){1,2} $", Alternation(vec![ Concat(vec![ Symbol(Start), Symbol(Named(Ident::new("S1"))), Repetition( Box::new(Repetition( Box::new(Symbol(Named(Ident::new("S2")))), ZeroOrMore, )), AtMostOne, ), Repetition( Box::new(Group(Box::new(Concat(vec![ Exclude(Named(Ident::new("S3"))), Symbol(Named(Ident::new("S4"))), ])))), OneOrMore, ), ]), Concat(vec![ Repetition( Box::new(Permute(vec![ Named(Ident::new("S1")), Named(Ident::new("S2")), ])), Range(1, 2), ), Symbol(End), ]), ]), ); } #[test] fn test_select_wildcard_with_replace() { let sql = r#"SELECT * REPLACE (lower(city) AS city) FROM addresses"#; let dialects = TestedDialects::new(vec![ Box::new(GenericDialect {}), Box::new(BigQueryDialect {}), Box::new(ClickHouseDialect {}), Box::new(SnowflakeDialect {}), Box::new(DuckDbDialect {}), ]); let select = dialects.verified_only_select(sql); let expected = SelectItem::Wildcard(WildcardAdditionalOptions { opt_replace: Some(ReplaceSelectItem { items: vec![Box::new(ReplaceSelectElement { expr: call("lower", [Expr::Identifier(Ident::new("city"))]), column_name: Ident::new("city"), as_keyword: true, })], }), ..Default::default() }); assert_eq!(expected, select.projection[0]); let select = dialects.verified_only_select(r#"SELECT * REPLACE ('widget' AS item_name) FROM orders"#); let expected = SelectItem::Wildcard(WildcardAdditionalOptions { opt_replace: Some(ReplaceSelectItem { items: vec![Box::new(ReplaceSelectElement { expr: Expr::Value( (Value::SingleQuotedString("widget".to_owned())).with_empty_span(), ), column_name: Ident::new("item_name"), as_keyword: true, })], }), ..Default::default() }); assert_eq!(expected, select.projection[0]); let select = dialects.verified_only_select( r#"SELECT * REPLACE (quantity / 2 AS quantity, 3 AS order_id) FROM orders"#, ); let expected = SelectItem::Wildcard(WildcardAdditionalOptions { opt_replace: Some(ReplaceSelectItem { items: vec![ Box::new(ReplaceSelectElement { expr: Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("quantity"))), op: BinaryOperator::Divide, right: Box::new(Expr::value(number("2"))), }, column_name: Ident::new("quantity"), as_keyword: true, }), Box::new(ReplaceSelectElement { expr: Expr::value(number("3")), column_name: Ident::new("order_id"), as_keyword: true, }), ], }), ..Default::default() }); assert_eq!(expected, select.projection[0]); } #[test] fn parse_sized_list() { let dialects = TestedDialects::new(vec![ Box::new(GenericDialect {}), Box::new(PostgreSqlDialect {}), Box::new(DuckDbDialect {}), ]); let sql = r#"CREATE TABLE embeddings (data FLOAT[1536])"#; dialects.verified_stmt(sql); let sql = r#"CREATE TABLE embeddings (data FLOAT[1536][3])"#; dialects.verified_stmt(sql); let sql = r#"SELECT data::FLOAT[1536] FROM embeddings"#; dialects.verified_stmt(sql); } #[test] fn insert_into_with_parentheses() { let dialects = TestedDialects::new(vec![ Box::new(SnowflakeDialect {}), Box::new(RedshiftSqlDialect {}), Box::new(GenericDialect {}), ]); dialects.verified_stmt("INSERT INTO t1 (id, name) (SELECT t2.id, t2.name FROM t2)"); dialects.verified_stmt("INSERT INTO t1 (SELECT t2.id, t2.name FROM t2)"); dialects.verified_stmt(r#"INSERT INTO t1 ("select", name) (SELECT t2.name FROM t2)"#); } #[test] fn test_insert_with_query_table() { let dialects = all_dialects_where(|d| d.supports_insert_table_query()); // a simple query (block); i.e. SELECT ... let sql = "INSERT INTO (SELECT employee_id, last_name FROM employees) VALUES (207, 'Gregory')"; dialects.verified_stmt(sql); // a full blown query; i.e. `WITH ... SELECT .. ORDER BY ...` let sql = "INSERT INTO \ (WITH cte AS (SELECT 1 AS id, 2 AS val FROM dual) SELECT foo_t.id, foo_t.val FROM foo_t \ WHERE EXISTS (SELECT 1 FROM cte WHERE cte.id = foo_t.id) ORDER BY 1, 2) \ (id, val) \ VALUES (1000, 10101)"; dialects.verified_stmt(sql); // an alias to the insert target query table let sql = "INSERT INTO \ (WITH cte AS (SELECT 1 AS id, 2 AS val FROM dual) SELECT foo_t.id, foo_t.val FROM foo_t \ WHERE EXISTS (SELECT 1 FROM cte WHERE cte.id = foo_t.id)) abc \ (id, val) \ VALUES (1000, 10101)"; dialects.verified_stmt(sql); // a query table target and a query source let sql = "INSERT INTO (SELECT foo_t.id, foo_t.val FROM foo_t) SELECT 10, 20 FROM dual"; dialects.verified_stmt(sql); // a query table target and a query source, with explicit columns let sql = "INSERT INTO (SELECT foo_t.id, foo_t.val FROM foo_t) (id, val) SELECT 10, 20 FROM dual"; dialects.verified_stmt(sql); } #[test] fn parse_odbc_scalar_function() { let select = verified_only_select("SELECT {fn my_func(1, 2)}"); let Expr::Function(Function { name, uses_odbc_syntax, args, .. }) = expr_from_projection(only(&select.projection)) else { unreachable!("expected function") }; assert_eq!(name, &ObjectName::from(vec![Ident::new("my_func")])); assert!(uses_odbc_syntax); matches!(args, FunctionArguments::List(l) if l.args.len() == 2); verified_stmt("SELECT {fn fna()} AS foo, fnb(1)"); // Testing invalid SQL with any-one dialect is intentional. // Depending on dialect flags the error message may be different. let pg = TestedDialects::new(vec![Box::new(PostgreSqlDialect {})]); assert_eq!( pg.parse_sql_statements("SELECT {fn2 my_func()}") .unwrap_err() .to_string(), "sql parser error: Expected: an expression, found: {" ); } #[test] fn test_dictionary_syntax() { fn check(sql: &str, expect: Expr) { assert_eq!( all_dialects_where(|d| d.supports_dictionary_syntax()).verified_expr(sql), expect ); } check("{}", Expr::Dictionary(vec![])); check( "{'Alberta': 'Edmonton', 'Manitoba': 'Winnipeg'}", Expr::Dictionary(vec![ DictionaryField { key: Ident::with_quote('\'', "Alberta"), value: Box::new(Expr::Value( (Value::SingleQuotedString("Edmonton".to_owned())).with_empty_span(), )), }, DictionaryField { key: Ident::with_quote('\'', "Manitoba"), value: Box::new(Expr::Value( (Value::SingleQuotedString("Winnipeg".to_owned())).with_empty_span(), )), }, ]), ); check( "{'start': CAST('2023-04-01' AS TIMESTAMP), 'end': CAST('2023-04-05' AS TIMESTAMP)}", Expr::Dictionary(vec![ DictionaryField { key: Ident::with_quote('\'', "start"), value: Box::new(Expr::Cast { kind: CastKind::Cast, expr: Box::new(Expr::Value( (Value::SingleQuotedString("2023-04-01".to_owned())).with_empty_span(), )), data_type: DataType::Timestamp(None, TimezoneInfo::None), array: false, format: None, }), }, DictionaryField { key: Ident::with_quote('\'', "end"), value: Box::new(Expr::Cast { kind: CastKind::Cast, expr: Box::new(Expr::Value( (Value::SingleQuotedString("2023-04-05".to_owned())).with_empty_span(), )), data_type: DataType::Timestamp(None, TimezoneInfo::None), array: false, format: None, }), }, ]), ) } #[test] fn test_map_syntax() { fn check(sql: &str, expect: Expr) { assert_eq!( all_dialects_where(|d| d.support_map_literal_syntax()).verified_expr(sql), expect ); } check( "MAP {'Alberta': 'Edmonton', 'Manitoba': 'Winnipeg'}", Expr::Map(Map { entries: vec![ MapEntry { key: Box::new(Expr::Value( (Value::SingleQuotedString("Alberta".to_owned())).with_empty_span(), )), value: Box::new(Expr::Value( (Value::SingleQuotedString("Edmonton".to_owned())).with_empty_span(), )), }, MapEntry { key: Box::new(Expr::Value( (Value::SingleQuotedString("Manitoba".to_owned())).with_empty_span(), )), value: Box::new(Expr::Value( (Value::SingleQuotedString("Winnipeg".to_owned())).with_empty_span(), )), }, ], }), ); fn number_expr(s: &str) -> Expr { Expr::value(number(s)) } fn null_expr() -> Expr { Expr::Value((Value::Null).with_empty_span()) } check( "MAP {1: 10.0, 2: 20.0}", Expr::Map(Map { entries: vec![ MapEntry { key: Box::new(number_expr("1")), value: Box::new(number_expr("10.0")), }, MapEntry { key: Box::new(number_expr("2")), value: Box::new(number_expr("20.0")), }, ], }), ); check( "MAP {[1, 2, 3]: 10.0, [4, 5, 6]: 20.0}", Expr::Map(Map { entries: vec![ MapEntry { key: Box::new(Expr::Array(Array { elem: vec![number_expr("1"), number_expr("2"), number_expr("3")], named: false, })), value: Box::new(Expr::value(number("10.0"))), }, MapEntry { key: Box::new(Expr::Array(Array { elem: vec![number_expr("4"), number_expr("5"), number_expr("6")], named: false, })), value: Box::new(Expr::value(number("20.0"))), }, ], }), ); check( "MAP {'a': 10, 'b': 20}['a']", Expr::CompoundFieldAccess { root: Box::new(Expr::Map(Map { entries: vec![ MapEntry { key: Box::new(Expr::Value( (Value::SingleQuotedString("a".to_owned())).with_empty_span(), )), value: Box::new(number_expr("10")), }, MapEntry { key: Box::new(Expr::Value( (Value::SingleQuotedString("b".to_owned())).with_empty_span(), )), value: Box::new(number_expr("20")), }, ], })), access_chain: vec![AccessExpr::Subscript(Subscript::Index { index: Expr::Value((Value::SingleQuotedString("a".to_owned())).with_empty_span()), })], }, ); check("MAP {}", Expr::Map(Map { entries: vec![] })); check( "MAP {'a': 1, 'b': NULL}", Expr::Map(Map { entries: vec![ MapEntry { key: Box::new(Expr::Value( (Value::SingleQuotedString("a".to_owned())).with_empty_span(), )), value: Box::new(number_expr("1")), }, MapEntry { key: Box::new(Expr::Value( (Value::SingleQuotedString("b".to_owned())).with_empty_span(), )), value: Box::new(null_expr()), }, ], }), ); check( "MAP {1: [1, NULL, 3], 2: [4, NULL, 6], 3: [7, 8, 9]}", Expr::Map(Map { entries: vec![ MapEntry { key: Box::new(number_expr("1")), value: Box::new(Expr::Array(Array { elem: vec![number_expr("1"), null_expr(), number_expr("3")], named: false, })), }, MapEntry { key: Box::new(number_expr("2")), value: Box::new(Expr::Array(Array { elem: vec![number_expr("4"), null_expr(), number_expr("6")], named: false, })), }, MapEntry { key: Box::new(number_expr("3")), value: Box::new(Expr::Array(Array { elem: vec![number_expr("7"), number_expr("8"), number_expr("9")], named: false, })), }, ], }), ); } #[test] fn parse_within_group() { verified_expr("PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY sales_amount)"); verified_expr(concat!( "PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY sales_amount) ", "OVER (PARTITION BY department)", )); } #[test] fn tests_select_values_without_parens() { let dialects = TestedDialects::new(vec![ Box::new(GenericDialect {}), Box::new(SnowflakeDialect {}), Box::new(DatabricksDialect {}), ]); let sql = "SELECT * FROM VALUES (1, 2), (2,3) AS tbl (id, val)"; let canonical = "SELECT * FROM (VALUES (1, 2), (2, 3)) AS tbl (id, val)"; dialects.verified_only_select_with_canonical(sql, canonical); } #[test] fn tests_select_values_without_parens_and_set_op() { let dialects = TestedDialects::new(vec![ Box::new(GenericDialect {}), Box::new(SnowflakeDialect {}), Box::new(DatabricksDialect {}), ]); let sql = "SELECT id + 1, name FROM VALUES (1, 'Apple'), (2, 'Banana'), (3, 'Orange') AS fruits (id, name) UNION ALL SELECT 5, 'Strawberry'"; let canonical = "SELECT id + 1, name FROM (VALUES (1, 'Apple'), (2, 'Banana'), (3, 'Orange')) AS fruits (id, name) UNION ALL SELECT 5, 'Strawberry'"; let query = dialects.verified_query_with_canonical(sql, canonical); match *query.body { SetExpr::SetOperation { op, set_quantifier: _, left, right, } => { assert_eq!(SetOperator::Union, op); match *left { SetExpr::Select(_) => {} _ => panic!("Expected: a SELECT statement"), } match *right { SetExpr::Select(_) => {} _ => panic!("Expected: a SELECT statement"), } } _ => panic!("Expected: a SET OPERATION"), } } #[test] fn parse_select_wildcard_with_except() { let dialects = all_dialects_where(|d| d.supports_select_wildcard_except()); let select = dialects.verified_only_select("SELECT * EXCEPT (col_a) FROM data"); let expected = SelectItem::Wildcard(WildcardAdditionalOptions { opt_except: Some(ExceptSelectItem { first_element: Ident::new("col_a"), additional_elements: vec![], }), ..Default::default() }); assert_eq!(expected, select.projection[0]); let select = dialects .verified_only_select("SELECT * EXCEPT (department_id, employee_id) FROM employee_table"); let expected = SelectItem::Wildcard(WildcardAdditionalOptions { opt_except: Some(ExceptSelectItem { first_element: Ident::new("department_id"), additional_elements: vec![Ident::new("employee_id")], }), ..Default::default() }); assert_eq!(expected, select.projection[0]); assert_eq!( dialects .parse_sql_statements("SELECT * EXCEPT () FROM employee_table") .unwrap_err() .to_string(), "sql parser error: Expected: identifier, found: )" ); } #[test] fn test_group_by_nothing() { let Select { group_by, .. } = all_dialects_where(|d| d.supports_group_by_expr()) .verified_only_select("SELECT count(1) FROM t GROUP BY ()"); { assert_eq!( GroupByExpr::Expressions(vec![Expr::Tuple(vec![])], vec![]), group_by ); } let Select { group_by, .. } = all_dialects_where(|d| d.supports_group_by_expr()) .verified_only_select("SELECT name, count(1) FROM t GROUP BY name, ()"); { assert_eq!( GroupByExpr::Expressions( vec![ Identifier(Ident::new("name".to_string())), Expr::Tuple(vec![]) ], vec![] ), group_by ); } } #[test] fn test_extract_seconds_ok() { let dialects = all_dialects_where(|d| d.allow_extract_custom()); let stmt = dialects.verified_expr("EXTRACT(SECONDS FROM '2 seconds'::INTERVAL)"); assert_eq!( stmt, Expr::Extract { field: Seconds, syntax: ExtractSyntax::From, expr: Box::new(Expr::Cast { kind: CastKind::DoubleColon, expr: Box::new(Expr::Value( (Value::SingleQuotedString("2 seconds".to_string())).with_empty_span() )), data_type: DataType::Interval { fields: None, precision: None }, array: false, format: None, }), } ); let actual_ast = dialects .parse_sql_statements("SELECT EXTRACT(seconds FROM '2 seconds'::INTERVAL)") .unwrap(); let expected_ast = vec![Statement::Query(Box::new(Query { with: None, body: Box::new(SetExpr::Select(Box::new(Select { select_token: AttachedToken::empty(), optimizer_hints: vec![], distinct: None, select_modifiers: None, top: None, top_before_distinct: false, projection: vec![UnnamedExpr(Expr::Extract { field: Seconds, syntax: ExtractSyntax::From, expr: Box::new(Expr::Cast { kind: CastKind::DoubleColon, expr: Box::new(Expr::Value( (Value::SingleQuotedString("2 seconds".to_string())).with_empty_span(), )), data_type: DataType::Interval { fields: None, precision: None, }, array: false, format: None, }), })], exclude: None, into: None, from: vec![], lateral_views: vec![], prewhere: None, selection: None, group_by: GroupByExpr::Expressions(vec![], vec![]), cluster_by: vec![], distribute_by: vec![], sort_by: vec![], having: None, named_window: vec![], qualify: None, window_before_qualify: false, value_table_mode: None, connect_by: vec![], flavor: SelectFlavor::Standard, }))), order_by: None, limit_clause: None, fetch: None, locks: vec![], for_clause: None, settings: None, format_clause: None, pipe_operators: vec![], }))]; assert_eq!(actual_ast, expected_ast); } #[test] fn test_extract_seconds_single_quote_ok() { let dialects = all_dialects_where(|d| d.allow_extract_custom()); let stmt = dialects.verified_expr(r#"EXTRACT('seconds' FROM '2 seconds'::INTERVAL)"#); assert_eq!( stmt, Expr::Extract { field: DateTimeField::Custom(Ident { value: "seconds".to_string(), quote_style: Some('\''), span: Span::empty(), }), syntax: ExtractSyntax::From, expr: Box::new(Expr::Cast { kind: CastKind::DoubleColon, expr: Box::new(Expr::Value( (Value::SingleQuotedString("2 seconds".to_string())).with_empty_span() )), data_type: DataType::Interval { fields: None, precision: None }, array: false, format: None, }), } ) } #[test] fn test_extract_seconds_single_quote_err() { let sql = r#"SELECT EXTRACT('seconds' FROM '2 seconds'::INTERVAL)"#; let dialects = all_dialects_except(|d| d.allow_extract_single_quotes()); let err = dialects.parse_sql_statements(sql).unwrap_err(); assert_eq!( err.to_string(), "sql parser error: Expected: date/time field, found: 'seconds'" ); } #[test] fn test_truncate_table_with_on_cluster() { let sql = "TRUNCATE TABLE t ON CLUSTER cluster_name"; match all_dialects().verified_stmt(sql) { Statement::Truncate(truncate) => { assert_eq!(truncate.on_cluster, Some(Ident::new("cluster_name"))); } _ => panic!("Expected: TRUNCATE TABLE statement"), } // Omit ON CLUSTER is allowed all_dialects().verified_stmt("TRUNCATE TABLE t"); assert_eq!( ParserError::ParserError("Expected: identifier, found: EOF".to_string()), all_dialects() .parse_sql_statements("TRUNCATE TABLE t ON CLUSTER") .unwrap_err() ); } #[test] fn parse_explain_with_option_list() { run_explain_analyze( all_dialects_where(|d| d.supports_explain_with_utility_options()), "EXPLAIN (ANALYZE false, VERBOSE true) SELECT sqrt(id) FROM foo", false, false, None, Some(vec![ UtilityOption { name: Ident::new("ANALYZE"), arg: Some(Expr::Value((Value::Boolean(false)).with_empty_span())), }, UtilityOption { name: Ident::new("VERBOSE"), arg: Some(Expr::Value((Value::Boolean(true)).with_empty_span())), }, ]), ); run_explain_analyze( all_dialects_where(|d| d.supports_explain_with_utility_options()), "EXPLAIN (ANALYZE ON, VERBOSE OFF) SELECT sqrt(id) FROM foo", false, false, None, Some(vec![ UtilityOption { name: Ident::new("ANALYZE"), arg: Some(Expr::Identifier(Ident::new("ON"))), }, UtilityOption { name: Ident::new("VERBOSE"), arg: Some(Expr::Identifier(Ident::new("OFF"))), }, ]), ); run_explain_analyze( all_dialects_where(|d| d.supports_explain_with_utility_options()), r#"EXPLAIN (FORMAT1 TEXT, FORMAT2 'JSON', FORMAT3 "XML", FORMAT4 YAML) SELECT sqrt(id) FROM foo"#, false, false, None, Some(vec![ UtilityOption { name: Ident::new("FORMAT1"), arg: Some(Expr::Identifier(Ident::new("TEXT"))), }, UtilityOption { name: Ident::new("FORMAT2"), arg: Some(Expr::Value( (Value::SingleQuotedString("JSON".to_string())).with_empty_span(), )), }, UtilityOption { name: Ident::new("FORMAT3"), arg: Some(Expr::Identifier(Ident::with_quote('"', "XML"))), }, UtilityOption { name: Ident::new("FORMAT4"), arg: Some(Expr::Identifier(Ident::new("YAML"))), }, ]), ); run_explain_analyze( all_dialects_where(|d| d.supports_explain_with_utility_options()), r#"EXPLAIN (NUM1 10, NUM2 +10.1, NUM3 -10.2) SELECT sqrt(id) FROM foo"#, false, false, None, Some(vec![ UtilityOption { name: Ident::new("NUM1"), arg: Some(Expr::Value( (Value::Number("10".parse().unwrap(), false)).with_empty_span(), )), }, UtilityOption { name: Ident::new("NUM2"), arg: Some(Expr::UnaryOp { op: UnaryOperator::Plus, expr: Box::new(Expr::Value( (Value::Number("10.1".parse().unwrap(), false)).with_empty_span(), )), }), }, UtilityOption { name: Ident::new("NUM3"), arg: Some(Expr::UnaryOp { op: UnaryOperator::Minus, expr: Box::new(Expr::Value( (Value::Number("10.2".parse().unwrap(), false)).with_empty_span(), )), }), }, ]), ); let utility_options = vec![ UtilityOption { name: Ident::new("ANALYZE"), arg: None, }, UtilityOption { name: Ident::new("VERBOSE"), arg: Some(Expr::Value((Value::Boolean(true)).with_empty_span())), }, UtilityOption { name: Ident::new("WAL"), arg: Some(Expr::Identifier(Ident::new("OFF"))), }, UtilityOption { name: Ident::new("FORMAT"), arg: Some(Expr::Identifier(Ident::new("YAML"))), }, UtilityOption { name: Ident::new("USER_DEF_NUM"), arg: Some(Expr::UnaryOp { op: UnaryOperator::Minus, expr: Box::new(Expr::Value( (Value::Number("100.1".parse().unwrap(), false)).with_empty_span(), )), }), }, ]; run_explain_analyze( all_dialects_where(|d| d.supports_explain_with_utility_options()), "EXPLAIN (ANALYZE, VERBOSE true, WAL OFF, FORMAT YAML, USER_DEF_NUM -100.1) SELECT sqrt(id) FROM foo", false, false, None, Some(utility_options), ); } #[test] fn test_create_policy() { let sql: &str = "CREATE POLICY my_policy ON my_table \ AS PERMISSIVE FOR SELECT \ TO my_role, CURRENT_USER \ USING (c0 = 1) \ WITH CHECK (1 = 1)"; match all_dialects().verified_stmt(sql) { Statement::CreatePolicy(CreatePolicy { name, table_name, to, using, with_check, .. }) => { assert_eq!(name.to_string(), "my_policy"); assert_eq!(table_name.to_string(), "my_table"); assert_eq!( to, Some(vec![ Owner::Ident(Ident::new("my_role")), Owner::CurrentUser ]) ); assert_eq!( using, Some(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("c0"))), op: BinaryOperator::Eq, right: Box::new(Expr::Value( (Value::Number("1".parse().unwrap(), false)).with_empty_span() )), }) ); assert_eq!( with_check, Some(Expr::BinaryOp { left: Box::new(Expr::Value( (Value::Number("1".parse().unwrap(), false)).with_empty_span() )), op: BinaryOperator::Eq, right: Box::new(Expr::Value( (Value::Number("1".parse().unwrap(), false)).with_empty_span() )), }) ); } _ => unreachable!(), } // USING with SELECT query all_dialects().verified_stmt(concat!( "CREATE POLICY my_policy ON my_table ", "AS PERMISSIVE FOR SELECT ", "TO my_role, CURRENT_USER ", "USING (c0 IN (SELECT column FROM t0)) ", "WITH CHECK (1 = 1)" )); // omit AS / FOR / TO / USING / WITH CHECK clauses is allowed all_dialects().verified_stmt("CREATE POLICY my_policy ON my_table"); // missing table name assert_eq!( all_dialects() .parse_sql_statements("CREATE POLICY my_policy") .unwrap_err() .to_string(), "sql parser error: Expected: ON, found: EOF" ); // missing policy type assert_eq!( all_dialects() .parse_sql_statements("CREATE POLICY my_policy ON my_table AS") .unwrap_err() .to_string(), "sql parser error: Expected: one of PERMISSIVE or RESTRICTIVE, found: EOF" ); // missing FOR command assert_eq!( all_dialects() .parse_sql_statements("CREATE POLICY my_policy ON my_table FOR") .unwrap_err() .to_string(), "sql parser error: Expected: one of ALL or SELECT or INSERT or UPDATE or DELETE, found: EOF" ); // missing TO owners assert_eq!( all_dialects() .parse_sql_statements("CREATE POLICY my_policy ON my_table TO") .unwrap_err() .to_string(), "sql parser error: Expected: CURRENT_USER, CURRENT_ROLE, SESSION_USER or identifier after OWNER TO. sql parser error: Expected: identifier, found: EOF" ); // missing USING expression assert_eq!( all_dialects() .parse_sql_statements("CREATE POLICY my_policy ON my_table USING") .unwrap_err() .to_string(), "sql parser error: Expected: (, found: EOF" ); // missing WITH CHECK expression assert_eq!( all_dialects() .parse_sql_statements("CREATE POLICY my_policy ON my_table WITH CHECK") .unwrap_err() .to_string(), "sql parser error: Expected: (, found: EOF" ); } #[test] fn test_drop_policy() { let sql = "DROP POLICY IF EXISTS my_policy ON my_table RESTRICT"; match all_dialects().verified_stmt(sql) { Statement::DropPolicy(DropPolicy { if_exists, name, table_name, drop_behavior, }) => { assert_eq!(if_exists, true); assert_eq!(name.to_string(), "my_policy"); assert_eq!(table_name.to_string(), "my_table"); assert_eq!(drop_behavior, Some(DropBehavior::Restrict)); } _ => unreachable!(), } // omit IF EXISTS is allowed all_dialects().verified_stmt("DROP POLICY my_policy ON my_table CASCADE"); // omit option is allowed all_dialects().verified_stmt("DROP POLICY my_policy ON my_table"); // missing table name assert_eq!( all_dialects() .parse_sql_statements("DROP POLICY my_policy") .unwrap_err() .to_string(), "sql parser error: Expected: ON, found: EOF" ); // Wrong option name assert_eq!( all_dialects() .parse_sql_statements("DROP POLICY my_policy ON my_table WRONG") .unwrap_err() .to_string(), "sql parser error: Expected: end of statement, found: WRONG" ); } #[test] fn test_alter_policy() { match verified_stmt("ALTER POLICY old_policy ON my_table RENAME TO new_policy") { Statement::AlterPolicy(AlterPolicy { name, table_name, operation, .. }) => { assert_eq!(name.to_string(), "old_policy"); assert_eq!(table_name.to_string(), "my_table"); assert_eq!( operation, AlterPolicyOperation::Rename { new_name: Ident::new("new_policy") } ); } _ => unreachable!(), } match verified_stmt(concat!( "ALTER POLICY my_policy ON my_table TO CURRENT_USER ", "USING ((SELECT c0)) WITH CHECK (c0 > 0)" )) { Statement::AlterPolicy(AlterPolicy { name, table_name, .. }) => { assert_eq!(name.to_string(), "my_policy"); assert_eq!(table_name.to_string(), "my_table"); } _ => unreachable!(), } // omit TO / USING / WITH CHECK clauses is allowed verified_stmt("ALTER POLICY my_policy ON my_table"); // mixing RENAME and APPLY expressions assert_eq!( parse_sql_statements("ALTER POLICY old_policy ON my_table TO public RENAME TO new_policy") .unwrap_err() .to_string(), "sql parser error: Expected: end of statement, found: RENAME" ); assert_eq!( parse_sql_statements("ALTER POLICY old_policy ON my_table RENAME TO new_policy TO public") .unwrap_err() .to_string(), "sql parser error: Expected: end of statement, found: TO" ); // missing TO in RENAME TO assert_eq!( parse_sql_statements("ALTER POLICY old_policy ON my_table RENAME") .unwrap_err() .to_string(), "sql parser error: Expected: TO, found: EOF" ); // missing new name in RENAME TO assert_eq!( parse_sql_statements("ALTER POLICY old_policy ON my_table RENAME TO") .unwrap_err() .to_string(), "sql parser error: Expected: identifier, found: EOF" ); // missing the expression in USING assert_eq!( parse_sql_statements("ALTER POLICY my_policy ON my_table USING") .unwrap_err() .to_string(), "sql parser error: Expected: (, found: EOF" ); // missing the expression in WITH CHECK assert_eq!( parse_sql_statements("ALTER POLICY my_policy ON my_table WITH CHECK") .unwrap_err() .to_string(), "sql parser error: Expected: (, found: EOF" ); } #[test] fn test_create_connector() { let sql = "CREATE CONNECTOR my_connector \ TYPE 'jdbc' \ URL 'jdbc:mysql://localhost:3306/mydb' \ WITH DCPROPERTIES('user' = 'root', 'password' = 'password')"; let dialects = all_dialects(); match dialects.verified_stmt(sql) { Statement::CreateConnector(CreateConnector { name, connector_type, url, with_dcproperties, .. }) => { assert_eq!(name.to_string(), "my_connector"); assert_eq!(connector_type, Some("jdbc".to_string())); assert_eq!(url, Some("jdbc:mysql://localhost:3306/mydb".to_string())); assert_eq!( with_dcproperties, Some(vec![ SqlOption::KeyValue { key: Ident::with_quote('\'', "user"), value: Expr::Value( (Value::SingleQuotedString("root".to_string())).with_empty_span() ) }, SqlOption::KeyValue { key: Ident::with_quote('\'', "password"), value: Expr::Value( (Value::SingleQuotedString("password".to_string())).with_empty_span() ) } ]) ); } _ => unreachable!(), } // omit IF NOT EXISTS/TYPE/URL/COMMENT/WITH DCPROPERTIES clauses is allowed dialects.verified_stmt("CREATE CONNECTOR my_connector"); // missing connector name assert_eq!( dialects .parse_sql_statements("CREATE CONNECTOR") .unwrap_err() .to_string(), "sql parser error: Expected: identifier, found: EOF" ); } #[test] fn test_drop_connector() { let dialects = all_dialects(); match dialects.verified_stmt("DROP CONNECTOR IF EXISTS my_connector") { Statement::DropConnector { if_exists, name } => { assert_eq!(if_exists, true); assert_eq!(name.to_string(), "my_connector"); } _ => unreachable!(), } // omit IF EXISTS is allowed dialects.verified_stmt("DROP CONNECTOR my_connector"); // missing connector name assert_eq!( dialects .parse_sql_statements("DROP CONNECTOR") .unwrap_err() .to_string(), "sql parser error: Expected: identifier, found: EOF" ); } #[test] fn test_alter_connector() { let dialects = all_dialects(); match dialects.verified_stmt( "ALTER CONNECTOR my_connector SET DCPROPERTIES('user' = 'root', 'password' = 'password')", ) { Statement::AlterConnector { name, properties, url, owner, } => { assert_eq!(name.to_string(), "my_connector"); assert_eq!( properties, Some(vec![ SqlOption::KeyValue { key: Ident::with_quote('\'', "user"), value: Expr::Value( (Value::SingleQuotedString("root".to_string())).with_empty_span() ) }, SqlOption::KeyValue { key: Ident::with_quote('\'', "password"), value: Expr::Value( (Value::SingleQuotedString("password".to_string())).with_empty_span() ) } ]) ); assert_eq!(url, None); assert_eq!(owner, None); } _ => unreachable!(), } match dialects .verified_stmt("ALTER CONNECTOR my_connector SET URL 'jdbc:mysql://localhost:3306/mydb'") { Statement::AlterConnector { name, properties, url, owner, } => { assert_eq!(name.to_string(), "my_connector"); assert_eq!(properties, None); assert_eq!(url, Some("jdbc:mysql://localhost:3306/mydb".to_string())); assert_eq!(owner, None); } _ => unreachable!(), } match dialects.verified_stmt("ALTER CONNECTOR my_connector SET OWNER USER 'root'") { Statement::AlterConnector { name, properties, url, owner, } => { assert_eq!(name.to_string(), "my_connector"); assert_eq!(properties, None); assert_eq!(url, None); assert_eq!( owner, Some(AlterConnectorOwner::User(Ident::with_quote('\'', "root"))) ); } _ => unreachable!(), } match dialects.verified_stmt("ALTER CONNECTOR my_connector SET OWNER ROLE 'admin'") { Statement::AlterConnector { name, properties, url, owner, } => { assert_eq!(name.to_string(), "my_connector"); assert_eq!(properties, None); assert_eq!(url, None); assert_eq!( owner, Some(AlterConnectorOwner::Role(Ident::with_quote('\'', "admin"))) ); } _ => unreachable!(), } // Wrong option name assert_eq!( dialects .parse_sql_statements( "ALTER CONNECTOR my_connector SET WRONG 'jdbc:mysql://localhost:3306/mydb'" ) .unwrap_err() .to_string(), "sql parser error: Expected: end of statement, found: WRONG" ); } #[test] fn test_select_where_with_like_or_ilike_any() { verified_stmt(r#"SELECT * FROM x WHERE a ILIKE ANY '%abc%'"#); verified_stmt(r#"SELECT * FROM x WHERE a LIKE ANY '%abc%'"#); verified_stmt(r#"SELECT * FROM x WHERE a ILIKE ANY ('%Jo%oe%', 'T%e')"#); verified_stmt(r#"SELECT * FROM x WHERE a LIKE ANY ('%Jo%oe%', 'T%e')"#); } #[test] fn test_any_some_all_comparison() { verified_stmt("SELECT c1 FROM tbl WHERE c1 = ANY(SELECT c2 FROM tbl)"); verified_stmt("SELECT c1 FROM tbl WHERE c1 >= ALL(SELECT c2 FROM tbl)"); verified_stmt("SELECT c1 FROM tbl WHERE c1 <> SOME(SELECT c2 FROM tbl)"); verified_stmt("SELECT 1 = ANY(WITH x AS (SELECT 1) SELECT * FROM x)"); } #[test] fn test_alias_equal_expr() { let dialects = all_dialects_where(|d| d.supports_eq_alias_assignment()); let sql = r#"SELECT some_alias = some_column FROM some_table"#; let expected = r#"SELECT some_column AS some_alias FROM some_table"#; let _ = dialects.one_statement_parses_to(sql, expected); let sql = r#"SELECT some_alias = (a*b) FROM some_table"#; let expected = r#"SELECT (a * b) AS some_alias FROM some_table"#; let _ = dialects.one_statement_parses_to(sql, expected); let dialects = all_dialects_where(|d| !d.supports_eq_alias_assignment()); let sql = r#"SELECT x = (a * b) FROM some_table"#; let expected = r#"SELECT x = (a * b) FROM some_table"#; let _ = dialects.one_statement_parses_to(sql, expected); } #[test] fn test_try_convert() { let dialects = all_dialects_where(|d| d.supports_try_convert() && d.convert_type_before_value()); dialects.verified_expr("TRY_CONVERT(VARCHAR(MAX), 'foo')"); let dialects = all_dialects_where(|d| d.supports_try_convert() && !d.convert_type_before_value()); dialects.verified_expr("TRY_CONVERT('foo', VARCHAR(MAX))"); } #[test] fn parse_method_select() { let _ = verified_only_select( "SELECT LEFT('abc', 1).value('.', 'NVARCHAR(MAX)').value('.', 'NVARCHAR(MAX)') AS T", ); let _ = verified_only_select("SELECT STUFF((SELECT ',' + name FROM sys.objects FOR XML PATH(''), TYPE).value('.', 'NVARCHAR(MAX)'), 1, 1, '') AS T"); let _ = verified_only_select("SELECT CAST(column AS XML).value('.', 'NVARCHAR(MAX)') AS T"); // `CONVERT` support let dialects = all_dialects_where(|d| d.supports_try_convert() && d.convert_type_before_value()); let _ = dialects.verified_only_select("SELECT CONVERT(XML, 'abc').value('.', 'NVARCHAR(MAX)').value('.', 'NVARCHAR(MAX)') AS T"); } #[test] fn parse_method_expr() { let expr = verified_expr("LEFT('abc', 1).value('.', 'NVARCHAR(MAX)').value('.', 'NVARCHAR(MAX)')"); match expr { Expr::CompoundFieldAccess { root, access_chain } => { assert!(matches!(*root, Expr::Function(_))); assert!(matches!( access_chain[..], [ AccessExpr::Dot(Expr::Function(_)), AccessExpr::Dot(Expr::Function(_)) ] )); } _ => unreachable!(), } let expr = verified_expr( "(SELECT ',' + name FROM sys.objects FOR XML PATH(''), TYPE).value('.', 'NVARCHAR(MAX)')", ); match expr { Expr::CompoundFieldAccess { root, access_chain } => { assert!(matches!(*root, Expr::Subquery(_))); assert!(matches!( access_chain[..], [AccessExpr::Dot(Expr::Function(_))] )); } _ => unreachable!(), } let expr = verified_expr("CAST(column AS XML).value('.', 'NVARCHAR(MAX)')"); match expr { Expr::CompoundFieldAccess { root, access_chain } => { assert!(matches!(*root, Expr::Cast { .. })); assert!(matches!( access_chain[..], [AccessExpr::Dot(Expr::Function(_))] )); } _ => unreachable!(), } // `CONVERT` support let dialects = all_dialects_where(|d| d.supports_try_convert() && d.convert_type_before_value()); let expr = dialects.verified_expr( "CONVERT(XML, 'abc').value('.', 'NVARCHAR(MAX)').value('.', 'NVARCHAR(MAX)')", ); match expr { Expr::CompoundFieldAccess { root, access_chain } => { assert!(matches!(*root, Expr::Convert { .. })); assert!(matches!( access_chain[..], [ AccessExpr::Dot(Expr::Function(_)), AccessExpr::Dot(Expr::Function(_)) ] )); } _ => unreachable!(), } } #[test] fn test_show_dbs_schemas_tables_views() { // These statements are parsed the same by all dialects let stmts = vec![ "SHOW CATALOGS", "SHOW DATABASES", "SHOW SCHEMAS", "SHOW TABLES", "SHOW VIEWS", "SHOW TABLES IN db1", "SHOW VIEWS FROM db1", "SHOW MATERIALIZED VIEWS", "SHOW MATERIALIZED VIEWS IN db1", "SHOW MATERIALIZED VIEWS FROM db1", ]; for stmt in stmts { verified_stmt(stmt); } // These statements are parsed the same by all dialects // except for how the parser interprets the location of // LIKE option (infix/suffix) let stmts = vec![ "SHOW CATALOGS LIKE '%abc'", "SHOW DATABASES LIKE '%abc'", "SHOW SCHEMAS LIKE '%abc'", ]; for stmt in stmts { all_dialects_where(|d| d.supports_show_like_before_in()).verified_stmt(stmt); all_dialects_where(|d| !d.supports_show_like_before_in()).verified_stmt(stmt); } // These statements are only parsed by dialects that // support the LIKE option in the suffix let stmts = vec![ "SHOW TABLES IN db1 'abc'", "SHOW VIEWS IN db1 'abc'", "SHOW VIEWS FROM db1 'abc'", "SHOW MATERIALIZED VIEWS IN db1 'abc'", "SHOW MATERIALIZED VIEWS FROM db1 'abc'", ]; for stmt in stmts { all_dialects_where(|d| !d.supports_show_like_before_in()).verified_stmt(stmt); } } #[test] fn parse_listen_channel() { let dialects = all_dialects_where(|d| d.supports_listen_notify()); match dialects.verified_stmt("LISTEN test1") { Statement::LISTEN { channel } => { assert_eq!(Ident::new("test1"), channel); } _ => unreachable!(), }; assert_eq!( dialects.parse_sql_statements("LISTEN *").unwrap_err(), ParserError::ParserError("Expected: identifier, found: *".to_string()) ); let dialects = all_dialects_where(|d| !d.supports_listen_notify()); assert_eq!( dialects.parse_sql_statements("LISTEN test1").unwrap_err(), ParserError::ParserError("Expected: an SQL statement, found: LISTEN".to_string()) ); } #[test] fn parse_unlisten_channel() { let dialects = all_dialects_where(|d| d.supports_listen_notify()); match dialects.verified_stmt("UNLISTEN test1") { Statement::UNLISTEN { channel } => { assert_eq!(Ident::new("test1"), channel); } _ => unreachable!(), }; match dialects.verified_stmt("UNLISTEN *") { Statement::UNLISTEN { channel } => { assert_eq!(Ident::new("*"), channel); } _ => unreachable!(), }; assert_eq!( dialects.parse_sql_statements("UNLISTEN +").unwrap_err(), ParserError::ParserError("Expected: wildcard or identifier, found: +".to_string()) ); let dialects = all_dialects_where(|d| !d.supports_listen_notify()); assert_eq!( dialects.parse_sql_statements("UNLISTEN test1").unwrap_err(), ParserError::ParserError("Expected: an SQL statement, found: UNLISTEN".to_string()) ); } #[test] fn parse_notify_channel() { let dialects = all_dialects_where(|d| d.supports_listen_notify()); match dialects.verified_stmt("NOTIFY test1") { Statement::NOTIFY { channel, payload } => { assert_eq!(Ident::new("test1"), channel); assert_eq!(payload, None); } _ => unreachable!(), }; match dialects.verified_stmt("NOTIFY test1, 'this is a test notification'") { Statement::NOTIFY { channel, payload: Some(payload), } => { assert_eq!(Ident::new("test1"), channel); assert_eq!("this is a test notification", payload); } _ => unreachable!(), }; assert_eq!( dialects.parse_sql_statements("NOTIFY *").unwrap_err(), ParserError::ParserError("Expected: identifier, found: *".to_string()) ); assert_eq!( dialects .parse_sql_statements("NOTIFY test1, *") .unwrap_err(), ParserError::ParserError("Expected: literal string, found: *".to_string()) ); let sql_statements = [ "NOTIFY test1", "NOTIFY test1, 'this is a test notification'", ]; let dialects = all_dialects_where(|d| !d.supports_listen_notify()); for &sql in &sql_statements { assert_eq!( dialects.parse_sql_statements(sql).unwrap_err(), ParserError::ParserError("Expected: an SQL statement, found: NOTIFY".to_string()) ); } } #[test] fn parse_load_data() { let dialects = all_dialects_where(|d| d.supports_load_data()); let only_supports_load_extension_dialects = all_dialects_where(|d| !d.supports_load_data() && d.supports_load_extension()); let not_supports_load_dialects = all_dialects_where(|d| !d.supports_load_data() && !d.supports_load_extension()); let sql = "LOAD DATA INPATH '/local/path/to/data.txt' INTO TABLE test.my_table"; match dialects.verified_stmt(sql) { Statement::LoadData { local, inpath, overwrite, table_name, partitioned, table_format, } => { assert_eq!(false, local); assert_eq!("/local/path/to/data.txt", inpath); assert_eq!(false, overwrite); assert_eq!( ObjectName::from(vec![Ident::new("test"), Ident::new("my_table")]), table_name ); assert_eq!(None, partitioned); assert_eq!(None, table_format); } _ => unreachable!(), }; // with OVERWRITE keyword let sql = "LOAD DATA INPATH '/local/path/to/data.txt' OVERWRITE INTO TABLE my_table"; match dialects.verified_stmt(sql) { Statement::LoadData { local, inpath, overwrite, table_name, partitioned, table_format, } => { assert_eq!(false, local); assert_eq!("/local/path/to/data.txt", inpath); assert_eq!(true, overwrite); assert_eq!(ObjectName::from(vec![Ident::new("my_table")]), table_name); assert_eq!(None, partitioned); assert_eq!(None, table_format); } _ => unreachable!(), }; assert_eq!( only_supports_load_extension_dialects .parse_sql_statements(sql) .unwrap_err(), ParserError::ParserError("Expected: end of statement, found: INPATH".to_string()) ); assert_eq!( not_supports_load_dialects .parse_sql_statements(sql) .unwrap_err(), ParserError::ParserError( "Expected: `DATA` or an extension name after `LOAD`, found: INPATH".to_string() ) ); // with LOCAL keyword let sql = "LOAD DATA LOCAL INPATH '/local/path/to/data.txt' INTO TABLE test.my_table"; match dialects.verified_stmt(sql) { Statement::LoadData { local, inpath, overwrite, table_name, partitioned, table_format, } => { assert_eq!(true, local); assert_eq!("/local/path/to/data.txt", inpath); assert_eq!(false, overwrite); assert_eq!( ObjectName::from(vec![Ident::new("test"), Ident::new("my_table")]), table_name ); assert_eq!(None, partitioned); assert_eq!(None, table_format); } _ => unreachable!(), }; assert_eq!( only_supports_load_extension_dialects .parse_sql_statements(sql) .unwrap_err(), ParserError::ParserError("Expected: end of statement, found: LOCAL".to_string()) ); assert_eq!( not_supports_load_dialects .parse_sql_statements(sql) .unwrap_err(), ParserError::ParserError( "Expected: `DATA` or an extension name after `LOAD`, found: LOCAL".to_string() ) ); // with PARTITION clause let sql = "LOAD DATA LOCAL INPATH '/local/path/to/data.txt' INTO TABLE my_table PARTITION (year = 2024, month = 11)"; match dialects.verified_stmt(sql) { Statement::LoadData { local, inpath, overwrite, table_name, partitioned, table_format, } => { assert_eq!(true, local); assert_eq!("/local/path/to/data.txt", inpath); assert_eq!(false, overwrite); assert_eq!(ObjectName::from(vec![Ident::new("my_table")]), table_name); assert_eq!( Some(vec![ Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("year"))), op: BinaryOperator::Eq, right: Box::new(Expr::Value( (Value::Number("2024".parse().unwrap(), false)).with_empty_span() )), }, Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("month"))), op: BinaryOperator::Eq, right: Box::new(Expr::Value( (Value::Number("11".parse().unwrap(), false)).with_empty_span() )), } ]), partitioned ); assert_eq!(None, table_format); } _ => unreachable!(), }; // with PARTITION clause let sql = "LOAD DATA LOCAL INPATH '/local/path/to/data.txt' OVERWRITE INTO TABLE good.my_table PARTITION (year = 2024, month = 11) INPUTFORMAT 'org.apache.hadoop.mapred.TextInputFormat' SERDE 'org.apache.hadoop.hive.serde2.OpenCSVSerde'"; match dialects.verified_stmt(sql) { Statement::LoadData { local, inpath, overwrite, table_name, partitioned, table_format, } => { assert_eq!(true, local); assert_eq!("/local/path/to/data.txt", inpath); assert_eq!(true, overwrite); assert_eq!( ObjectName::from(vec![Ident::new("good"), Ident::new("my_table")]), table_name ); assert_eq!( Some(vec![ Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("year"))), op: BinaryOperator::Eq, right: Box::new(Expr::Value( (Value::Number("2024".parse().unwrap(), false)).with_empty_span() )), }, Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("month"))), op: BinaryOperator::Eq, right: Box::new(Expr::Value( (Value::Number("11".parse().unwrap(), false)).with_empty_span() )), } ]), partitioned ); assert_eq!( Some(HiveLoadDataFormat { serde: Expr::Value( (Value::SingleQuotedString( "org.apache.hadoop.hive.serde2.OpenCSVSerde".to_string() )) .with_empty_span() ), input_format: Expr::Value( (Value::SingleQuotedString( "org.apache.hadoop.mapred.TextInputFormat".to_string() )) .with_empty_span() ) }), table_format ); } _ => unreachable!(), }; // negative test case let sql = "LOAD DATA2 LOCAL INPATH '/local/path/to/data.txt' INTO TABLE test.my_table"; assert_eq!( dialects.parse_sql_statements(sql).unwrap_err(), ParserError::ParserError( "Expected: `DATA` or an extension name after `LOAD`, found: DATA2".to_string() ) ); } #[test] fn test_load_extension() { let dialects = all_dialects_where(|d| d.supports_load_extension()); let not_supports_load_extension_dialects = all_dialects_where(|d| !d.supports_load_extension()); let sql = "LOAD my_extension"; match dialects.verified_stmt(sql) { Statement::Load { extension_name } => { assert_eq!(Ident::new("my_extension"), extension_name); } _ => unreachable!(), }; assert_eq!( not_supports_load_extension_dialects .parse_sql_statements(sql) .unwrap_err(), ParserError::ParserError( "Expected: `DATA` or an extension name after `LOAD`, found: my_extension".to_string() ) ); let sql = "LOAD 'filename'"; match dialects.verified_stmt(sql) { Statement::Load { extension_name } => { assert_eq!( Ident { value: "filename".to_string(), quote_style: Some('\''), span: Span::empty(), }, extension_name ); } _ => unreachable!(), }; } #[test] fn test_select_top() { let dialects = all_dialects_where(|d| d.supports_top_before_distinct()); dialects.verified_stmt("SELECT ALL * FROM tbl"); dialects.verified_stmt("SELECT TOP 3 * FROM tbl"); dialects.verified_stmt("SELECT TOP 3 ALL * FROM tbl"); dialects.verified_stmt("SELECT TOP 3 DISTINCT * FROM tbl"); dialects.verified_stmt("SELECT TOP 3 DISTINCT a, b, c FROM tbl"); } #[test] fn parse_bang_not() { let dialects = all_dialects_where(|d| d.supports_bang_not_operator()); let sql = "SELECT !a, !(b > 3)"; let Select { projection, .. } = dialects.verified_only_select(sql); for (i, expr) in [ Box::new(Expr::Identifier(Ident::new("a"))), Box::new(Expr::Nested(Box::new(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("b"))), op: BinaryOperator::Gt, right: Box::new(Expr::Value( Value::Number("3".parse().unwrap(), false).with_empty_span(), )), }))), ] .into_iter() .enumerate() { assert_eq!( SelectItem::UnnamedExpr(Expr::UnaryOp { op: UnaryOperator::BangNot, expr }), projection[i] ) } let sql_statements = ["SELECT a!", "SELECT a ! b", "SELECT a ! as b"]; for &sql in &sql_statements { assert_eq!( dialects.parse_sql_statements(sql).unwrap_err(), ParserError::ParserError("No infix parser for token ExclamationMark".to_string()) ); } let sql_statements = ["SELECT !a", "SELECT !a b", "SELECT !a as b"]; let dialects = all_dialects_where(|d| !d.supports_bang_not_operator()); for &sql in &sql_statements { assert_eq!( dialects.parse_sql_statements(sql).unwrap_err(), ParserError::ParserError("Expected: an expression, found: !".to_string()) ); } } #[test] fn parse_factorial_operator() { let dialects = all_dialects_where(|d| d.supports_factorial_operator()); let sql = "SELECT a!, (b + c)!"; let Select { projection, .. } = dialects.verified_only_select(sql); for (i, expr) in [ Box::new(Expr::Identifier(Ident::new("a"))), Box::new(Expr::Nested(Box::new(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("b"))), op: BinaryOperator::Plus, right: Box::new(Expr::Identifier(Ident::new("c"))), }))), ] .into_iter() .enumerate() { assert_eq!( SelectItem::UnnamedExpr(Expr::UnaryOp { op: UnaryOperator::PGPostfixFactorial, expr }), projection[i] ) } let sql_statements = ["SELECT !a", "SELECT !a b", "SELECT !a as b"]; for &sql in &sql_statements { assert_eq!( dialects.parse_sql_statements(sql).unwrap_err(), ParserError::ParserError("Expected: an expression, found: !".to_string()) ); } let sql_statements = ["SELECT a!", "SELECT a ! b", "SELECT a ! as b"]; // Due to the exclamation mark, which is both part of the `bang not` operator // and the `factorial` operator, additional filtering not supports // `bang not` operator is required here. let dialects = all_dialects_where(|d| !d.supports_factorial_operator() && !d.supports_bang_not_operator()); for &sql in &sql_statements { assert_eq!( dialects.parse_sql_statements(sql).unwrap_err(), ParserError::ParserError("No infix parser for token ExclamationMark".to_string()) ); } // Due to the exclamation mark, which is both part of the `bang not` operator // and the `factorial` operator, additional filtering supports // `bang not` operator is required here. let dialects = all_dialects_where(|d| !d.supports_factorial_operator() && d.supports_bang_not_operator()); for &sql in &sql_statements { assert_eq!( dialects.parse_sql_statements(sql).unwrap_err(), ParserError::ParserError("No infix parser for token ExclamationMark".to_string()) ); } } #[test] fn parse_comments() { match all_dialects_where(|d| d.supports_comment_on()) .verified_stmt("COMMENT ON COLUMN tab.name IS 'comment'") { Statement::Comment { object_type, object_name, comment: Some(comment), if_exists, } => { assert_eq!("comment", comment); assert_eq!("tab.name", object_name.to_string()); assert_eq!(CommentObject::Column, object_type); assert!(!if_exists); } _ => unreachable!(), } // https://www.postgresql.org/docs/current/sql-comment.html let object_types = [ ("COLLATION", CommentObject::Collation), ("COLUMN", CommentObject::Column), ("DATABASE", CommentObject::Database), ("DOMAIN", CommentObject::Domain), ("EXTENSION", CommentObject::Extension), ("FUNCTION", CommentObject::Function), ("INDEX", CommentObject::Index), ("MATERIALIZED VIEW", CommentObject::MaterializedView), ("PROCEDURE", CommentObject::Procedure), ("ROLE", CommentObject::Role), ("SCHEMA", CommentObject::Schema), ("SEQUENCE", CommentObject::Sequence), ("TABLE", CommentObject::Table), ("TYPE", CommentObject::Type), ("USER", CommentObject::User), ("VIEW", CommentObject::View), ]; for (keyword, expected_object_type) in object_types.iter() { match all_dialects_where(|d| d.supports_comment_on()) .verified_stmt(format!("COMMENT IF EXISTS ON {keyword} db.t0 IS 'comment'").as_str()) { Statement::Comment { object_type, object_name, comment: Some(comment), if_exists, } => { assert_eq!("comment", comment); assert_eq!("db.t0", object_name.to_string()); assert_eq!(*expected_object_type, object_type); assert!(if_exists); } _ => unreachable!(), } } match all_dialects_where(|d| d.supports_comment_on()) .verified_stmt("COMMENT IF EXISTS ON TABLE public.tab IS NULL") { Statement::Comment { object_type, object_name, comment: None, if_exists, } => { assert_eq!("public.tab", object_name.to_string()); assert_eq!(CommentObject::Table, object_type); assert!(if_exists); } _ => unreachable!(), } // missing IS statement assert_eq!( all_dialects_where(|d| d.supports_comment_on()) .parse_sql_statements("COMMENT ON TABLE t0") .unwrap_err(), ParserError::ParserError("Expected: IS, found: EOF".to_string()) ); // missing comment literal assert_eq!( all_dialects_where(|d| d.supports_comment_on()) .parse_sql_statements("COMMENT ON TABLE t0 IS") .unwrap_err(), ParserError::ParserError("Expected: literal string, found: EOF".to_string()) ); // unknown object type assert_eq!( all_dialects_where(|d| d.supports_comment_on()) .parse_sql_statements("COMMENT ON UNKNOWN t0 IS 'comment'") .unwrap_err(), ParserError::ParserError("Expected: comment object_type, found: UNKNOWN".to_string()) ); } #[test] fn parse_create_table_select() { let dialects = all_dialects_where(|d| d.supports_create_table_select()); let sql_1 = r#"CREATE TABLE foo (baz INT) SELECT bar"#; let expected = r#"CREATE TABLE foo (baz INT) AS SELECT bar"#; let _ = dialects.one_statement_parses_to(sql_1, expected); let sql_2 = r#"CREATE TABLE foo (baz INT, name STRING) SELECT bar, oth_name FROM test.table_a"#; let expected = r#"CREATE TABLE foo (baz INT, name STRING) AS SELECT bar, oth_name FROM test.table_a"#; let _ = dialects.one_statement_parses_to(sql_2, expected); let dialects = all_dialects_where(|d| !d.supports_create_table_select()); for sql in [sql_1, sql_2] { assert_eq!( dialects.parse_sql_statements(sql).unwrap_err(), ParserError::ParserError("Expected: end of statement, found: SELECT".to_string()) ); } } #[test] fn test_reserved_keywords_for_identifiers() { let dialects = all_dialects_where(|d| d.is_reserved_for_identifier(Keyword::INTERVAL)); // Dialects that reserve the word INTERVAL will not allow it as an unquoted identifier let sql = "SELECT MAX(interval) FROM tbl"; assert_eq!( dialects.parse_sql_statements(sql), Err(ParserError::ParserError( "Expected: an expression, found: )".to_string() )) ); // Dialects that do not reserve the word INTERVAL will allow it let dialects = all_dialects_where(|d| !d.is_reserved_for_identifier(Keyword::INTERVAL)); let sql = "SELECT MAX(interval) FROM tbl"; dialects.parse_sql_statements(sql).unwrap(); } #[test] fn test_keywords_as_column_names_after_dot() { // Test various keywords that have special meaning when standalone // but should be treated as identifiers after a dot. let keywords = [ "interval", // INTERVAL '1' DAY "case", // CASE WHEN ... END "cast", // CAST(x AS y) "extract", // EXTRACT(DAY FROM ...) "trim", // TRIM(...) "substring", // SUBSTRING(...) "left", // LEFT(str, n) "right", // RIGHT(str, n) ]; for kw in keywords { let sql = format!("SELECT T.{kw} FROM T"); verified_stmt(&sql); let sql = format!("SELECT SUM(x) OVER (PARTITION BY T.{kw} ORDER BY T.id) FROM T"); verified_stmt(&sql); let sql = format!("SELECT T.{kw}, S.{kw} FROM T, S WHERE T.{kw} = S.{kw}"); verified_stmt(&sql); } let select = verified_only_select("SELECT T.interval, T.case FROM T"); match &select.projection[0] { SelectItem::UnnamedExpr(Expr::CompoundIdentifier(idents)) => { assert_eq!(idents.len(), 2); assert_eq!(idents[0].value, "T"); assert_eq!(idents[1].value, "interval"); } _ => panic!("Expected CompoundIdentifier for T.interval"), } match &select.projection[1] { SelectItem::UnnamedExpr(Expr::CompoundIdentifier(idents)) => { assert_eq!(idents.len(), 2); assert_eq!(idents[0].value, "T"); assert_eq!(idents[1].value, "case"); } _ => panic!("Expected CompoundIdentifier for T.case"), } } #[test] fn parse_create_table_with_bit_types() { let sql = "CREATE TABLE t (a BIT, b BIT VARYING, c BIT(42), d BIT VARYING(43))"; match verified_stmt(sql) { Statement::CreateTable(CreateTable { columns, .. }) => { assert_eq!(columns.len(), 4); assert_eq!(columns[0].data_type, DataType::Bit(None)); assert_eq!(columns[0].to_string(), "a BIT"); assert_eq!(columns[1].data_type, DataType::BitVarying(None)); assert_eq!(columns[1].to_string(), "b BIT VARYING"); assert_eq!(columns[2].data_type, DataType::Bit(Some(42))); assert_eq!(columns[2].to_string(), "c BIT(42)"); assert_eq!(columns[3].data_type, DataType::BitVarying(Some(43))); assert_eq!(columns[3].to_string(), "d BIT VARYING(43)"); } _ => unreachable!(), } } #[test] fn parse_composite_access_expr() { assert_eq!( verified_expr("f(a).b"), Expr::CompoundFieldAccess { root: Box::new(Expr::Function(Function { name: ObjectName::from(vec![Ident::new("f")]), uses_odbc_syntax: false, parameters: FunctionArguments::None, args: FunctionArguments::List(FunctionArgumentList { duplicate_treatment: None, args: vec![FunctionArg::Unnamed(FunctionArgExpr::Expr( Expr::Identifier(Ident::new("a")) ))], clauses: vec![], }), null_treatment: None, filter: None, over: None, within_group: vec![] })), access_chain: vec![AccessExpr::Dot(Expr::Identifier(Ident::new("b")))] } ); // Nested Composite Access assert_eq!( verified_expr("f(a).b.c"), Expr::CompoundFieldAccess { root: Box::new(Expr::Function(Function { name: ObjectName::from(vec![Ident::new("f")]), uses_odbc_syntax: false, parameters: FunctionArguments::None, args: FunctionArguments::List(FunctionArgumentList { duplicate_treatment: None, args: vec![FunctionArg::Unnamed(FunctionArgExpr::Expr( Expr::Identifier(Ident::new("a")) ))], clauses: vec![], }), null_treatment: None, filter: None, over: None, within_group: vec![] })), access_chain: vec![ AccessExpr::Dot(Expr::Identifier(Ident::new("b"))), AccessExpr::Dot(Expr::Identifier(Ident::new("c"))), ] } ); // Composite Access in Select and Where Clauses let stmt = verified_only_select("SELECT f(a).b FROM t WHERE f(a).b IS NOT NULL"); let expr = Expr::CompoundFieldAccess { root: Box::new(Expr::Function(Function { name: ObjectName::from(vec![Ident::new("f")]), uses_odbc_syntax: false, parameters: FunctionArguments::None, args: FunctionArguments::List(FunctionArgumentList { duplicate_treatment: None, args: vec![FunctionArg::Unnamed(FunctionArgExpr::Expr( Expr::Identifier(Ident::new("a")), ))], clauses: vec![], }), null_treatment: None, filter: None, over: None, within_group: vec![], })), access_chain: vec![AccessExpr::Dot(Expr::Identifier(Ident::new("b")))], }; assert_eq!(stmt.projection[0], SelectItem::UnnamedExpr(expr.clone())); assert_eq!(stmt.selection.unwrap(), Expr::IsNotNull(Box::new(expr))); // Compound access with quoted identifier. all_dialects_where(|d| d.is_delimited_identifier_start('"')) .verified_only_select("SELECT f(a).\"an id\""); // Composite Access in struct literal all_dialects_where(|d| d.supports_struct_literal()).verified_stmt( "SELECT * FROM t WHERE STRUCT(STRUCT(1 AS a, NULL AS b) AS c, NULL AS d).c.a IS NOT NULL", ); let support_struct = all_dialects_where(|d| d.supports_struct_literal()); let stmt = support_struct .verified_only_select("SELECT STRUCT(STRUCT(1 AS a, NULL AS b) AS c, NULL AS d).c.a"); let expected = SelectItem::UnnamedExpr(Expr::CompoundFieldAccess { root: Box::new(Expr::Struct { values: vec![ Expr::Named { name: Ident::new("c"), expr: Box::new(Expr::Struct { values: vec![ Expr::Named { name: Ident::new("a"), expr: Box::new(Expr::Value( (Number("1".parse().unwrap(), false)).with_empty_span(), )), }, Expr::Named { name: Ident::new("b"), expr: Box::new(Expr::Value((Value::Null).with_empty_span())), }, ], fields: vec![], }), }, Expr::Named { name: Ident::new("d"), expr: Box::new(Expr::Value((Value::Null).with_empty_span())), }, ], fields: vec![], }), access_chain: vec![ AccessExpr::Dot(Expr::Identifier(Ident::new("c"))), AccessExpr::Dot(Expr::Identifier(Ident::new("a"))), ], }); assert_eq!(stmt.projection[0], expected); } #[test] fn parse_create_table_with_enum_types() { let sql = "CREATE TABLE t0 (foo ENUM8('a' = 1, 'b' = 2), bar ENUM16('a' = 1, 'b' = 2), baz ENUM('a', 'b'))"; match all_dialects().verified_stmt(sql) { Statement::CreateTable(CreateTable { name, columns, .. }) => { assert_eq!(name.to_string(), "t0"); assert_eq!( vec![ ColumnDef { name: Ident::new("foo"), data_type: DataType::Enum( vec![ EnumMember::NamedValue( "a".to_string(), Expr::Value( (Number("1".parse().unwrap(), false)).with_empty_span() ) ), EnumMember::NamedValue( "b".to_string(), Expr::Value( (Number("2".parse().unwrap(), false)).with_empty_span() ) ) ], Some(8) ), options: vec![], }, ColumnDef { name: Ident::new("bar"), data_type: DataType::Enum( vec![ EnumMember::NamedValue( "a".to_string(), Expr::Value( (Number("1".parse().unwrap(), false)).with_empty_span() ) ), EnumMember::NamedValue( "b".to_string(), Expr::Value( (Number("2".parse().unwrap(), false)).with_empty_span() ) ) ], Some(16) ), options: vec![], }, ColumnDef { name: Ident::new("baz"), data_type: DataType::Enum( vec![ EnumMember::Name("a".to_string()), EnumMember::Name("b".to_string()) ], None ), options: vec![], } ], columns ); } _ => unreachable!(), } // invalid case missing value for enum pair assert_eq!( all_dialects() .parse_sql_statements("CREATE TABLE t0 (foo ENUM8('a' = 1, 'b' = ))") .unwrap_err(), ParserError::ParserError("Expected: a value, found: )".to_string()) ); // invalid case that name is not a string assert_eq!( all_dialects() .parse_sql_statements("CREATE TABLE t0 (foo ENUM8('a' = 1, 2))") .unwrap_err(), ParserError::ParserError("Expected: literal string, found: 2".to_string()) ); } #[test] fn test_table_sample() { let dialects = all_dialects_where(|d| d.supports_table_sample_before_alias()); dialects.verified_stmt("SELECT * FROM tbl TABLESAMPLE (50) AS t"); dialects.verified_stmt("SELECT * FROM tbl TABLESAMPLE (50 ROWS) AS t"); dialects.verified_stmt("SELECT * FROM tbl TABLESAMPLE (50 PERCENT) AS t"); let dialects = all_dialects_where(|d| !d.supports_table_sample_before_alias()); dialects.verified_stmt("SELECT * FROM tbl AS t TABLESAMPLE BERNOULLI (50)"); dialects.verified_stmt("SELECT * FROM tbl AS t TABLESAMPLE SYSTEM (50)"); dialects.verified_stmt("SELECT * FROM tbl AS t TABLESAMPLE SYSTEM (50) REPEATABLE (10)"); } #[test] fn overflow() { let expr = std::iter::repeat_n("1", 1000) .collect::>() .join(" + "); let sql = format!("SELECT {expr}"); let mut statements = Parser::parse_sql(&GenericDialect {}, sql.as_str()).unwrap(); let statement = statements.pop().unwrap(); assert_eq!(statement.to_string(), sql); } #[test] fn parse_deeply_nested_boolean_expr_does_not_stackoverflow() { fn build_nested_expr(depth: usize) -> String { if depth == 0 { return "x = 1".to_string(); } format!( "({} OR {} AND ({}))", build_nested_expr(0), build_nested_expr(0), build_nested_expr(depth - 1) ) } let depth = 200; let where_clause = build_nested_expr(depth); let sql = format!("SELECT pk FROM tab0 WHERE {where_clause}"); let mut statements = Parser::new(&GenericDialect {}) .try_with_sql(&sql) .expect("tokenize to work") .with_recursion_limit(depth * 10) .parse_statements() .unwrap(); let statement = statements.pop().unwrap(); assert_eq!(statement.to_string(), sql); } #[test] fn parse_select_without_projection() { let dialects = all_dialects_where(|d| d.supports_empty_projections()); dialects.verified_stmt("SELECT FROM users"); } #[test] fn parse_update_from_before_select() { verified_stmt("UPDATE t1 FROM (SELECT name, id FROM t1 GROUP BY id) AS t2 SET name = t2.name WHERE t1.id = t2.id"); verified_stmt("UPDATE t1 FROM U, (SELECT id FROM V) AS W SET a = b WHERE 1 = 1"); let query = "UPDATE t1 FROM (SELECT name, id FROM t1 GROUP BY id) AS t2 SET name = t2.name FROM (SELECT name from t2) AS t2"; assert_eq!( ParserError::ParserError("Expected: end of statement, found: FROM".to_string()), parse_sql_statements(query).unwrap_err() ); } #[test] fn parse_overlaps() { verified_stmt("SELECT (DATE '2016-01-10', DATE '2016-02-01') OVERLAPS (DATE '2016-01-20', DATE '2016-02-10')"); } #[test] fn parse_column_definition_trailing_commas() { let dialects = all_dialects_where(|d| d.supports_column_definition_trailing_commas()); dialects.one_statement_parses_to("CREATE TABLE T (x INT64,)", "CREATE TABLE T (x INT64)"); dialects.one_statement_parses_to( "CREATE TABLE T (x INT64, y INT64, )", "CREATE TABLE T (x INT64, y INT64)", ); dialects.one_statement_parses_to( "CREATE VIEW T (x, y, ) AS SELECT 1", "CREATE VIEW T (x, y) AS SELECT 1", ); let unsupported_dialects = all_dialects_where(|d| { !d.supports_projection_trailing_commas() && !d.supports_trailing_commas() }); assert_eq!( unsupported_dialects .parse_sql_statements("CREATE TABLE employees (name text, age int,)") .unwrap_err(), ParserError::ParserError( "Expected: column name or constraint definition, found: )".to_string() ), ); } #[test] fn test_trailing_commas_in_from() { let dialects = all_dialects_where(|d| d.supports_from_trailing_commas()); dialects.verified_only_select_with_canonical("SELECT 1, 2 FROM t,", "SELECT 1, 2 FROM t"); dialects .verified_only_select_with_canonical("SELECT 1, 2 FROM t1, t2,", "SELECT 1, 2 FROM t1, t2"); let sql = "SELECT a, FROM b, LIMIT 1"; let _ = dialects.parse_sql_statements(sql).unwrap(); let sql = "INSERT INTO a SELECT b FROM c,"; let _ = dialects.parse_sql_statements(sql).unwrap(); let sql = "SELECT a FROM b, HAVING COUNT(*) > 1"; let _ = dialects.parse_sql_statements(sql).unwrap(); let sql = "SELECT a FROM b, WHERE c = 1"; let _ = dialects.parse_sql_statements(sql).unwrap(); // nested let sql = "SELECT 1, 2 FROM (SELECT * FROM t,),"; let _ = dialects.parse_sql_statements(sql).unwrap(); // multiple_subqueries dialects.verified_only_select_with_canonical( "SELECT 1, 2 FROM (SELECT * FROM t1), (SELECT * FROM t2),", "SELECT 1, 2 FROM (SELECT * FROM t1), (SELECT * FROM t2)", ); } #[test] #[cfg(feature = "visitor")] fn test_visit_order() { let sql = "SELECT CASE a WHEN 1 THEN 2 WHEN 3 THEN 4 ELSE 5 END"; let stmt = verified_stmt(sql); let mut visited = vec![]; let _ = sqlparser::ast::visit_expressions(&stmt, |expr| { visited.push(expr.to_string()); core::ops::ControlFlow::<()>::Continue(()) }); assert_eq!( visited, [ "CASE a WHEN 1 THEN 2 WHEN 3 THEN 4 ELSE 5 END", "a", "1", "2", "3", "4", "5" ] ); } #[test] fn parse_case_statement() { let sql = "CASE 1 WHEN 2 THEN SELECT 1; SELECT 2; ELSE SELECT 3; END CASE"; let Statement::Case(stmt) = verified_stmt(sql) else { unreachable!() }; assert_eq!(Some(Expr::value(number("1"))), stmt.match_expr); assert_eq!( Some(Expr::value(number("2"))), stmt.when_blocks[0].condition ); assert_eq!(2, stmt.when_blocks[0].statements().len()); assert_eq!(1, stmt.else_block.unwrap().statements().len()); verified_stmt(concat!( "CASE 1", " WHEN a THEN", " SELECT 1; SELECT 2; SELECT 3;", " WHEN b THEN", " SELECT 4; SELECT 5;", " ELSE", " SELECT 7; SELECT 8;", " END CASE" )); verified_stmt(concat!( "CASE 1", " WHEN a THEN", " SELECT 1; SELECT 2; SELECT 3;", " WHEN b THEN", " SELECT 4; SELECT 5;", " END CASE" )); verified_stmt(concat!( "CASE 1", " WHEN a THEN", " SELECT 1; SELECT 2; SELECT 3;", " END CASE" )); verified_stmt(concat!( "CASE 1", " WHEN a THEN", " SELECT 1; SELECT 2; SELECT 3;", " END" )); assert_eq!( ParserError::ParserError("Expected: THEN, found: END".to_string()), parse_sql_statements("CASE 1 WHEN a END").unwrap_err() ); assert_eq!( ParserError::ParserError("Expected: WHEN, found: ELSE".to_string()), parse_sql_statements("CASE 1 ELSE SELECT 1; END").unwrap_err() ); } #[test] fn test_case_statement_span() { let sql = "CASE 1 WHEN 2 THEN SELECT 1; SELECT 2; ELSE SELECT 3; END CASE"; let mut parser = Parser::new(&GenericDialect {}).try_with_sql(sql).unwrap(); assert_eq!( parser.parse_statement().unwrap().span(), Span::new(Location::new(1, 1), Location::new(1, sql.len() as u64 + 1)) ); } #[test] fn parse_if_statement() { let dialects = all_dialects_except(|d| d.is::()); let sql = "IF 1 THEN SELECT 1; ELSEIF 2 THEN SELECT 2; ELSE SELECT 3; END IF"; let Statement::If(IfStatement { if_block, elseif_blocks, else_block, .. }) = dialects.verified_stmt(sql) else { unreachable!() }; assert_eq!(Some(Expr::value(number("1"))), if_block.condition); assert_eq!(Some(Expr::value(number("2"))), elseif_blocks[0].condition); assert_eq!(1, else_block.unwrap().statements().len()); dialects.verified_stmt(concat!( "IF 1 THEN", " SELECT 1;", " SELECT 2;", " SELECT 3;", " ELSEIF 2 THEN", " SELECT 4;", " SELECT 5;", " ELSEIF 3 THEN", " SELECT 6;", " SELECT 7;", " ELSE", " SELECT 8;", " SELECT 9;", " END IF" )); dialects.verified_stmt(concat!( "IF 1 THEN", " SELECT 1;", " SELECT 2;", " ELSE", " SELECT 3;", " SELECT 4;", " END IF" )); dialects.verified_stmt(concat!( "IF 1 THEN", " SELECT 1;", " SELECT 2;", " SELECT 3;", " ELSEIF 2 THEN", " SELECT 3;", " SELECT 4;", " END IF" )); dialects.verified_stmt(concat!("IF 1 THEN", " SELECT 1;", " SELECT 2;", " END IF")); dialects.verified_stmt(concat!( "IF (1) THEN", " SELECT 1;", " SELECT 2;", " END IF" )); dialects.verified_stmt("IF 1 THEN END IF"); dialects.verified_stmt("IF 1 THEN SELECT 1; ELSEIF 1 THEN END IF"); assert_eq!( ParserError::ParserError("Expected: IF, found: EOF".to_string()), dialects .parse_sql_statements("IF 1 THEN SELECT 1; ELSEIF 1 THEN SELECT 2; END") .unwrap_err() ); } #[test] fn test_if_statement_span() { let sql = "IF 1=1 THEN SELECT 1; ELSEIF 1=2 THEN SELECT 2; ELSE SELECT 3; END IF"; let mut parser = Parser::new(&GenericDialect {}).try_with_sql(sql).unwrap(); assert_eq!( parser.parse_statement().unwrap().span(), Span::new(Location::new(1, 1), Location::new(1, sql.len() as u64 + 1)) ); } #[test] fn test_if_statement_multiline_span() { let sql_line1 = "IF 1 = 1 THEN SELECT 1;"; let sql_line2 = "ELSEIF 1 = 2 THEN SELECT 2;"; let sql_line3 = "ELSE SELECT 3;"; let sql_line4 = "END IF"; let sql = [sql_line1, sql_line2, sql_line3, sql_line4].join("\n"); let mut parser = Parser::new(&GenericDialect {}).try_with_sql(&sql).unwrap(); assert_eq!( parser.parse_statement().unwrap().span(), Span::new( Location::new(1, 1), Location::new(4, sql_line4.len() as u64 + 1) ) ); } #[test] fn test_conditional_statement_span() { let sql = "IF 1=1 THEN SELECT 1; ELSEIF 1=2 THEN SELECT 2; ELSE SELECT 3; END IF"; let mut parser = Parser::new(&GenericDialect {}).try_with_sql(sql).unwrap(); match parser.parse_statement().unwrap() { Statement::If(IfStatement { if_block, elseif_blocks, else_block, .. }) => { assert_eq!( Span::new(Location::new(1, 1), Location::new(1, 21)), if_block.span() ); assert_eq!( Span::new(Location::new(1, 23), Location::new(1, 47)), elseif_blocks[0].span() ); assert_eq!( Span::new(Location::new(1, 49), Location::new(1, 62)), else_block.unwrap().span() ); } stmt => panic!("Unexpected statement: {stmt:?}"), } } #[test] fn parse_raise_statement() { let sql = "RAISE USING MESSAGE = 42"; let Statement::Raise(stmt) = verified_stmt(sql) else { unreachable!() }; assert_eq!( Some(RaiseStatementValue::UsingMessage(Expr::value(number("42")))), stmt.value ); verified_stmt("RAISE USING MESSAGE = 'error'"); verified_stmt("RAISE myerror"); verified_stmt("RAISE 42"); verified_stmt("RAISE using"); verified_stmt("RAISE"); assert_eq!( ParserError::ParserError("Expected: =, found: error".to_string()), parse_sql_statements("RAISE USING MESSAGE error").unwrap_err() ); } #[test] fn test_lambdas() { let dialects = all_dialects_where(|d| d.supports_lambda_functions()); #[rustfmt::skip] let sql = concat!( "SELECT array_sort(array('Hello', 'World'), ", "(p1, p2) -> CASE WHEN p1 = p2 THEN 0 ", "WHEN reverse(p1) < reverse(p2) THEN -1 ", "ELSE 1 END)", ); pretty_assertions::assert_eq!( SelectItem::UnnamedExpr(call( "array_sort", [ call( "array", [ Expr::Value( (Value::SingleQuotedString("Hello".to_owned())).with_empty_span() ), Expr::Value( (Value::SingleQuotedString("World".to_owned())).with_empty_span() ) ] ), Expr::Lambda(LambdaFunction { params: OneOrManyWithParens::Many(vec![ LambdaFunctionParameter { name: Ident::new("p1"), data_type: None }, LambdaFunctionParameter { name: Ident::new("p2"), data_type: None } ]), 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"))) } }, ], else_result: Some(Box::new(Expr::value(number("1")))), }), syntax: LambdaSyntax::Arrow, }) ] )), dialects.verified_only_select(sql).projection[0] ); dialects.verified_expr( "map_zip_with(map(1, 'a', 2, 'b'), map(1, 'x', 2, 'y'), (k, v1, v2) -> concat(v1, v2))", ); dialects.verified_expr("transform(array(1, 2, 3), x -> x + 1)"); // Ensure all lambda variants are parsed correctly dialects.verified_expr("a -> a * 2"); // Single parameter without type dialects.verified_expr("a INT -> a * 2"); // Single parameter with type dialects.verified_expr("(a, b) -> a * b"); // Multiple parameters without types dialects.verified_expr("(a INT, b FLOAT) -> a * b"); // Multiple parameters with types } #[test] fn test_select_from_first() { let dialects = all_dialects_where(|d| d.supports_from_first_select()); let q1 = "FROM capitals"; let q2 = "FROM capitals SELECT *"; for (q, flavor, projection) in [ (q1, SelectFlavor::FromFirstNoSelect, vec![]), ( q2, SelectFlavor::FromFirst, vec![SelectItem::Wildcard(WildcardAdditionalOptions::default())], ), ] { let ast = dialects.verified_query(q); let expected = Query { with: None, body: Box::new(SetExpr::Select(Box::new(Select { select_token: AttachedToken::empty(), optimizer_hints: vec![], distinct: None, select_modifiers: None, top: None, projection, exclude: None, top_before_distinct: false, into: None, from: vec![TableWithJoins { relation: table_from_name(ObjectName::from(vec![Ident { value: "capitals".to_string(), quote_style: None, span: Span::empty(), }])), joins: vec![], }], lateral_views: vec![], prewhere: None, selection: None, group_by: GroupByExpr::Expressions(vec![], vec![]), cluster_by: vec![], distribute_by: vec![], sort_by: vec![], having: None, named_window: vec![], window_before_qualify: false, qualify: None, value_table_mode: None, connect_by: vec![], flavor, }))), order_by: None, limit_clause: None, fetch: None, locks: vec![], for_clause: None, settings: None, format_clause: None, pipe_operators: vec![], }; assert_eq!(expected, ast); } } #[test] fn test_select_from_first_with_cte() { let dialects = all_dialects_where(|d| d.supports_from_first_select()); let q = "WITH test AS (FROM t SELECT a) FROM test SELECT 1"; let ast = dialects.verified_query(q); let ast_select = ast.body.as_select().unwrap(); let expected_body_select_projection = vec![SelectItem::UnnamedExpr(Expr::Value(ValueWithSpan { value: test_utils::number("1"), span: Span::empty(), }))]; let expected_body_from = vec![TableWithJoins { relation: table_from_name(ObjectName::from(vec![Ident { value: "test".to_string(), quote_style: None, span: Span::empty(), }])), joins: vec![], }]; assert_eq!(ast_select.projection, expected_body_select_projection); assert_eq!(ast_select.from, expected_body_from); } #[test] fn test_geometric_unary_operators() { // Number of points in path or polygon let sql = "# path '((1,0),(0,1),(-1,0))'"; assert!(matches!( all_dialects_where(|d| d.supports_geometric_types()).verified_expr(sql), Expr::UnaryOp { op: UnaryOperator::Hash, .. } )); // Length or circumference let sql = "@-@ path '((0,0),(1,0))'"; assert!(matches!( all_dialects_where(|d| d.supports_geometric_types()).verified_expr(sql), Expr::UnaryOp { op: UnaryOperator::AtDashAt, .. } )); // Center let sql = "@@ circle '((0,0),10)'"; assert!(matches!( all_dialects_where(|d| d.supports_geometric_types()).verified_expr(sql), Expr::UnaryOp { op: UnaryOperator::DoubleAt, .. } )); // Is horizontal? let sql = "?- lseg '((-1,0),(1,0))'"; assert!(matches!( all_dialects_where(|d| d.supports_geometric_types()).verified_expr(sql), Expr::UnaryOp { op: UnaryOperator::QuestionDash, .. } )); // Is vertical? let sql = "?| lseg '((-1,0),(1,0))'"; assert!(matches!( all_dialects_where(|d| d.supports_geometric_types()).verified_expr(sql), Expr::UnaryOp { op: UnaryOperator::QuestionPipe, .. } )); } #[test] fn test_geometry_type() { let sql = "point '1,2'"; assert_eq!( all_dialects_where(|d| d.supports_geometric_types()).verified_expr(sql), Expr::TypedString(TypedString { data_type: DataType::GeometricType(GeometricTypeKind::Point), value: ValueWithSpan { value: Value::SingleQuotedString("1,2".to_string()), span: Span::empty(), }, uses_odbc_syntax: false }) ); let sql = "line '1,2,3,4'"; assert_eq!( all_dialects_where(|d| d.supports_geometric_types()).verified_expr(sql), Expr::TypedString(TypedString { data_type: DataType::GeometricType(GeometricTypeKind::Line), value: ValueWithSpan { value: Value::SingleQuotedString("1,2,3,4".to_string()), span: Span::empty(), }, uses_odbc_syntax: false }) ); let sql = "path '1,2,3,4'"; assert_eq!( all_dialects_where(|d| d.supports_geometric_types()).verified_expr(sql), Expr::TypedString(TypedString { data_type: DataType::GeometricType(GeometricTypeKind::GeometricPath), value: ValueWithSpan { value: Value::SingleQuotedString("1,2,3,4".to_string()), span: Span::empty(), }, uses_odbc_syntax: false }) ); let sql = "box '1,2,3,4'"; assert_eq!( all_dialects_where(|d| d.supports_geometric_types()).verified_expr(sql), Expr::TypedString(TypedString { data_type: DataType::GeometricType(GeometricTypeKind::GeometricBox), value: ValueWithSpan { value: Value::SingleQuotedString("1,2,3,4".to_string()), span: Span::empty(), }, uses_odbc_syntax: false }) ); let sql = "circle '1,2,3'"; assert_eq!( all_dialects_where(|d| d.supports_geometric_types()).verified_expr(sql), Expr::TypedString(TypedString { data_type: DataType::GeometricType(GeometricTypeKind::Circle), value: ValueWithSpan { value: Value::SingleQuotedString("1,2,3".to_string()), span: Span::empty(), }, uses_odbc_syntax: false }) ); let sql = "polygon '1,2,3,4'"; assert_eq!( all_dialects_where(|d| d.supports_geometric_types()).verified_expr(sql), Expr::TypedString(TypedString { data_type: DataType::GeometricType(GeometricTypeKind::Polygon), value: ValueWithSpan { value: Value::SingleQuotedString("1,2,3,4".to_string()), span: Span::empty(), }, uses_odbc_syntax: false }) ); let sql = "lseg '1,2,3,4'"; assert_eq!( all_dialects_where(|d| d.supports_geometric_types()).verified_expr(sql), Expr::TypedString(TypedString { data_type: DataType::GeometricType(GeometricTypeKind::LineSegment), value: ValueWithSpan { value: Value::SingleQuotedString("1,2,3,4".to_string()), span: Span::empty(), }, uses_odbc_syntax: false }) ); } #[test] fn test_geometric_binary_operators() { // Translation plus let sql = "box '((0,0),(1,1))' + point '(2.0,0)'"; assert!(matches!( all_dialects_where(|d| d.supports_geometric_types()).verified_expr(sql), Expr::BinaryOp { op: BinaryOperator::Plus, .. } )); // Translation minus let sql = "box '((0,0),(1,1))' - point '(2.0,0)'"; assert!(matches!( all_dialects_where(|d| d.supports_geometric_types()).verified_expr(sql), Expr::BinaryOp { op: BinaryOperator::Minus, .. } )); // Scaling multiply let sql = "box '((0,0),(1,1))' * point '(2.0,0)'"; assert!(matches!( all_dialects_where(|d| d.supports_geometric_types()).verified_expr(sql), Expr::BinaryOp { op: BinaryOperator::Multiply, .. } )); // Scaling divide let sql = "box '((0,0),(1,1))' / point '(2.0,0)'"; assert!(matches!( all_dialects_where(|d| d.supports_geometric_types()).verified_expr(sql), Expr::BinaryOp { op: BinaryOperator::Divide, .. } )); // Intersection let sql = "'((1,-1),(-1,1))' # '((1,1),(-1,-1))'"; assert!(matches!( all_dialects_where(|d| d.supports_geometric_types()).verified_expr(sql), Expr::BinaryOp { op: BinaryOperator::PGBitwiseXor, .. } )); //Point of closest proximity let sql = "point '(0,0)' ## lseg '((2,0),(0,2))'"; assert!(matches!( all_dialects_where(|d| d.supports_geometric_types()).verified_expr(sql), Expr::BinaryOp { op: BinaryOperator::DoubleHash, .. } )); // Point of closest proximity let sql = "box '((0,0),(1,1))' && box '((0,0),(2,2))'"; assert!(matches!( all_dialects_where(|d| d.supports_geometric_types()).verified_expr(sql), Expr::BinaryOp { op: BinaryOperator::PGOverlap, .. } )); // Overlaps to left? let sql = "box '((0,0),(1,1))' &< box '((0,0),(2,2))'"; assert!(matches!( all_dialects_where(|d| d.supports_geometric_types()).verified_expr(sql), Expr::BinaryOp { op: BinaryOperator::AndLt, .. } )); // Overlaps to right? let sql = "box '((0,0),(3,3))' &> box '((0,0),(2,2))'"; assert!(matches!( all_dialects_where(|d| d.supports_geometric_types()).verified_expr(sql), Expr::BinaryOp { op: BinaryOperator::AndGt, .. } )); // Distance between let sql = "circle '((0,0),1)' <-> circle '((5,0),1)'"; assert!(matches!( all_dialects_where(|d| d.supports_geometric_types()).verified_expr(sql), Expr::BinaryOp { op: BinaryOperator::LtDashGt, .. } )); // Is left of? let sql = "circle '((0,0),1)' << circle '((5,0),1)'"; assert!(matches!( all_dialects_where(|d| d.supports_geometric_types()).verified_expr(sql), Expr::BinaryOp { op: BinaryOperator::PGBitwiseShiftLeft, .. } )); // Is right of? let sql = "circle '((5,0),1)' >> circle '((0,0),1)'"; assert!(matches!( all_dialects_where(|d| d.supports_geometric_types()).verified_expr(sql), Expr::BinaryOp { op: BinaryOperator::PGBitwiseShiftRight, .. } )); // Is below? let sql = "circle '((0,0),1)' <^ circle '((0,5),1)'"; assert!(matches!( all_dialects_where(|d| d.supports_geometric_types()).verified_expr(sql), Expr::BinaryOp { op: BinaryOperator::LtCaret, .. } )); // Intersects or overlaps let sql = "lseg '((-1,0),(1,0))' ?# box '((-2,-2),(2,2))'"; assert!(matches!( all_dialects_where(|d| d.supports_geometric_types()).verified_expr(sql), Expr::BinaryOp { op: BinaryOperator::QuestionHash, .. } )); // Is horizontal? let sql = "point '(1,0)' ?- point '(0,0)'"; assert!(matches!( all_dialects_where(|d| d.supports_geometric_types()).verified_expr(sql), Expr::BinaryOp { op: BinaryOperator::QuestionDash, .. } )); // Is perpendicular? let sql = "lseg '((0,0),(0,1))' ?-| lseg '((0,0),(1,0))'"; assert!(matches!( all_dialects_where(|d| d.supports_geometric_types()).verified_expr(sql), Expr::BinaryOp { op: BinaryOperator::QuestionDashPipe, .. } )); // Is vertical? let sql = "point '(0,1)' ?| point '(0,0)'"; assert!(matches!( all_dialects_where(|d| d.supports_geometric_types()).verified_expr(sql), Expr::BinaryOp { op: BinaryOperator::QuestionPipe, .. } )); // Are parallel? let sql = "lseg '((-1,0),(1,0))' ?|| lseg '((-1,2),(1,2))'"; assert!(matches!( all_dialects_where(|d| d.supports_geometric_types()).verified_expr(sql), Expr::BinaryOp { op: BinaryOperator::QuestionDoublePipe, .. } )); // Contained or on? let sql = "point '(1,1)' @ circle '((0,0),2)'"; assert!(matches!( all_dialects_where(|d| d.supports_geometric_types()).verified_expr(sql), Expr::BinaryOp { op: BinaryOperator::At, .. } )); // // Same as? let sql = "polygon '((0,0),(1,1))' ~= polygon '((1,1),(0,0))'"; assert!(matches!( all_dialects_where(|d| d.supports_geometric_types()).verified_expr(sql), Expr::BinaryOp { op: BinaryOperator::TildeEq, .. } )); // Is strictly below? let sql = "box '((0,0),(3,3))' <<| box '((3,4),(5,5))'"; assert!(matches!( all_dialects_where(|d| d.supports_geometric_types()).verified_expr(sql), Expr::BinaryOp { op: BinaryOperator::LtLtPipe, .. } )); // Is strictly above? let sql = "box '((3,4),(5,5))' |>> box '((0,0),(3,3))'"; assert!(matches!( all_dialects_where(|d| d.supports_geometric_types()).verified_expr(sql), Expr::BinaryOp { op: BinaryOperator::PipeGtGt, .. } )); // Does not extend above? let sql = "box '((0,0),(1,1))' &<| box '((0,0),(2,2))'"; assert!(matches!( all_dialects_where(|d| d.supports_geometric_types()).verified_expr(sql), Expr::BinaryOp { op: BinaryOperator::AndLtPipe, .. } )); // Does not extend below? let sql = "box '((0,0),(3,3))' |&> box '((0,0),(2,2))'"; assert!(matches!( all_dialects_where(|d| d.supports_geometric_types()).verified_expr(sql), Expr::BinaryOp { op: BinaryOperator::PipeAndGt, .. } )); } #[test] fn parse_array_type_def_with_brackets() { let dialects = all_dialects_where(|d| d.supports_array_typedef_with_brackets()); dialects.verified_stmt("SELECT x::INT[]"); dialects.verified_stmt("SELECT STRING_TO_ARRAY('1,2,3', ',')::INT[3]"); } #[test] fn parse_set_names() { let dialects = all_dialects_where(|d| d.supports_set_names()); dialects.verified_stmt("SET NAMES 'UTF8'"); dialects.verified_stmt("SET NAMES 'utf8'"); dialects.verified_stmt("SET NAMES UTF8 COLLATE bogus"); } #[test] fn parse_pipe_operator_as() { let dialects = all_dialects_where(|d| d.supports_pipe_operator()); dialects.verified_stmt("SELECT * FROM tbl |> AS new_users"); } #[test] fn parse_pipe_operator_select() { let dialects = all_dialects_where(|d| d.supports_pipe_operator()); dialects.verified_stmt("SELECT * FROM tbl |> SELECT id"); dialects.verified_stmt("SELECT * FROM tbl |> SELECT id, name"); dialects.verified_query_with_canonical( "SELECT * FROM tbl |> SELECT id user_id", "SELECT * FROM tbl |> SELECT id AS user_id", ); dialects.verified_stmt("SELECT * FROM tbl |> SELECT id AS user_id"); } #[test] fn parse_pipe_operator_extend() { let dialects = all_dialects_where(|d| d.supports_pipe_operator()); dialects.verified_stmt("SELECT * FROM tbl |> EXTEND id + 1 AS new_id"); dialects.verified_stmt("SELECT * FROM tbl |> EXTEND id AS new_id, name AS new_name"); dialects.verified_query_with_canonical( "SELECT * FROM tbl |> EXTEND id user_id", "SELECT * FROM tbl |> EXTEND id AS user_id", ); } #[test] fn parse_pipe_operator_set() { let dialects = all_dialects_where(|d| d.supports_pipe_operator()); dialects.verified_stmt("SELECT * FROM tbl |> SET id = id + 1"); dialects.verified_stmt("SELECT * FROM tbl |> SET id = id + 1, name = name + ' Doe'"); } #[test] fn parse_pipe_operator_drop() { let dialects = all_dialects_where(|d| d.supports_pipe_operator()); dialects.verified_stmt("SELECT * FROM tbl |> DROP id"); dialects.verified_stmt("SELECT * FROM tbl |> DROP id, name"); dialects.verified_stmt("SELECT * FROM tbl |> DROP c |> RENAME a AS x"); dialects.verified_stmt("SELECT * FROM tbl |> DROP a, b |> SELECT c"); } #[test] fn parse_pipe_operator_limit() { let dialects = all_dialects_where(|d| d.supports_pipe_operator()); dialects.verified_stmt("SELECT * FROM tbl |> LIMIT 10"); dialects.verified_stmt("SELECT * FROM tbl |> LIMIT 10 OFFSET 5"); dialects.verified_stmt("SELECT * FROM tbl |> LIMIT 10 |> LIMIT 5"); dialects.verified_stmt("SELECT * FROM tbl |> LIMIT 10 |> WHERE true"); } #[test] fn parse_pipe_operator_where() { let dialects = all_dialects_where(|d| d.supports_pipe_operator()); dialects.verified_stmt("SELECT * FROM tbl |> WHERE id = 1"); dialects.verified_stmt("SELECT * FROM tbl |> WHERE id = 1 AND name = 'John'"); dialects.verified_stmt("SELECT * FROM tbl |> WHERE id = 1 OR name = 'John'"); } #[test] fn parse_pipe_operator_aggregate() { let dialects = all_dialects_where(|d| d.supports_pipe_operator()); dialects.verified_stmt("SELECT * FROM tbl |> AGGREGATE COUNT(*)"); dialects.verified_query_with_canonical( "SELECT * FROM tbl |> AGGREGATE COUNT(*) total_users", "SELECT * FROM tbl |> AGGREGATE COUNT(*) AS total_users", ); dialects.verified_stmt("SELECT * FROM tbl |> AGGREGATE COUNT(*) AS total_users"); dialects.verified_stmt("SELECT * FROM tbl |> AGGREGATE COUNT(*), MIN(id)"); dialects.verified_stmt("SELECT * FROM tbl |> AGGREGATE SUM(o_totalprice) AS price, COUNT(*) AS cnt GROUP BY EXTRACT(YEAR FROM o_orderdate) AS year"); dialects.verified_stmt( "SELECT * FROM tbl |> AGGREGATE GROUP BY EXTRACT(YEAR FROM o_orderdate) AS year", ); dialects .verified_stmt("SELECT * FROM tbl |> AGGREGATE GROUP BY EXTRACT(YEAR FROM o_orderdate)"); dialects.verified_stmt("SELECT * FROM tbl |> AGGREGATE GROUP BY a, b"); dialects.verified_stmt("SELECT * FROM tbl |> AGGREGATE SUM(c) GROUP BY a, b"); dialects.verified_stmt("SELECT * FROM tbl |> AGGREGATE SUM(c) ASC"); } #[test] fn parse_pipe_operator_order_by() { let dialects = all_dialects_where(|d| d.supports_pipe_operator()); dialects.verified_stmt("SELECT * FROM tbl |> ORDER BY id ASC"); dialects.verified_stmt("SELECT * FROM tbl |> ORDER BY id DESC"); dialects.verified_stmt("SELECT * FROM tbl |> ORDER BY id DESC, name ASC"); } #[test] fn parse_pipe_operator_tablesample() { let dialects = all_dialects_where(|d| d.supports_pipe_operator()); dialects.verified_stmt("SELECT * FROM tbl |> TABLESAMPLE BERNOULLI (50)"); dialects.verified_stmt("SELECT * FROM tbl |> TABLESAMPLE SYSTEM (50 PERCENT)"); dialects.verified_stmt("SELECT * FROM tbl |> TABLESAMPLE SYSTEM (50) REPEATABLE (10)"); } #[test] fn parse_pipe_operator_rename() { let dialects = all_dialects_where(|d| d.supports_pipe_operator()); dialects.verified_stmt("SELECT * FROM tbl |> RENAME old_name AS new_name"); dialects.verified_stmt("SELECT * FROM tbl |> RENAME id AS user_id, name AS user_name"); dialects.verified_query_with_canonical( "SELECT * FROM tbl |> RENAME id user_id", "SELECT * FROM tbl |> RENAME id AS user_id", ); } #[test] fn parse_pipe_operator_union() { let dialects = all_dialects_where(|d| d.supports_pipe_operator()); dialects.verified_stmt("SELECT * FROM tbl |> UNION ALL (SELECT * FROM admins)"); dialects.verified_stmt("SELECT * FROM tbl |> UNION DISTINCT (SELECT * FROM admins)"); dialects.verified_stmt("SELECT * FROM tbl |> UNION (SELECT * FROM admins)"); dialects.verified_stmt( "SELECT * FROM tbl |> UNION ALL (SELECT * FROM admins), (SELECT * FROM guests)", ); dialects.verified_stmt("SELECT * FROM tbl |> UNION DISTINCT (SELECT * FROM admins), (SELECT * FROM guests), (SELECT * FROM employees)"); dialects .verified_stmt("SELECT * FROM tbl |> UNION (SELECT * FROM admins), (SELECT * FROM guests)"); dialects.verified_stmt("SELECT * FROM tbl |> UNION BY NAME (SELECT * FROM admins)"); dialects.verified_stmt("SELECT * FROM tbl |> UNION ALL BY NAME (SELECT * FROM admins)"); dialects.verified_stmt("SELECT * FROM tbl |> UNION DISTINCT BY NAME (SELECT * FROM admins)"); dialects.verified_stmt( "SELECT * FROM tbl |> UNION BY NAME (SELECT * FROM admins), (SELECT * FROM guests)", ); } #[test] fn parse_pipe_operator_intersect() { let dialects = all_dialects_where(|d| d.supports_pipe_operator()); dialects.verified_stmt("SELECT * FROM tbl |> INTERSECT DISTINCT (SELECT * FROM admins)"); dialects .verified_stmt("SELECT * FROM tbl |> INTERSECT DISTINCT BY NAME (SELECT * FROM admins)"); dialects.verified_stmt( "SELECT * FROM tbl |> INTERSECT DISTINCT (SELECT * FROM admins), (SELECT * FROM guests)", ); dialects.verified_stmt("SELECT * FROM tbl |> INTERSECT DISTINCT BY NAME (SELECT * FROM admins), (SELECT * FROM guests)"); } #[test] fn parse_pipe_operator_except() { let dialects = all_dialects_where(|d| d.supports_pipe_operator()); dialects.verified_stmt("SELECT * FROM tbl |> EXCEPT DISTINCT (SELECT * FROM admins)"); dialects.verified_stmt("SELECT * FROM tbl |> EXCEPT DISTINCT BY NAME (SELECT * FROM admins)"); dialects.verified_stmt( "SELECT * FROM tbl |> EXCEPT DISTINCT (SELECT * FROM admins), (SELECT * FROM guests)", ); dialects.verified_stmt("SELECT * FROM tbl |> EXCEPT DISTINCT BY NAME (SELECT * FROM admins), (SELECT * FROM guests)"); } #[test] fn parse_pipe_operator_call() { let dialects = all_dialects_where(|d| d.supports_pipe_operator()); dialects.verified_stmt("SELECT * FROM tbl |> CALL my_function()"); dialects.verified_stmt("SELECT * FROM tbl |> CALL process_data(5, 'test')"); dialects .verified_stmt("SELECT * FROM tbl |> CALL namespace.function_name(col1, col2, 'literal')"); dialects.verified_stmt("SELECT * FROM tbl |> CALL transform_data(col1 + col2)"); dialects.verified_stmt("SELECT * FROM tbl |> CALL analyze_data('param1', 100, true)"); dialects.verified_stmt("SELECT * FROM tbl |> CALL tvf1(arg1) AS al"); dialects.verified_stmt("SELECT * FROM tbl |> CALL process_data(5) AS result_table"); dialects.verified_stmt("SELECT * FROM tbl |> CALL namespace.func() AS my_alias"); dialects.verified_stmt("SELECT * FROM tbl |> CALL tvf1(arg1) |> CALL tvf2(arg2, arg3)"); dialects.verified_stmt( "SELECT * FROM tbl |> CALL transform(col1) |> CALL validate() |> CALL process(param)", ); dialects .verified_stmt("SELECT * FROM tbl |> CALL tvf1(arg1) AS step1 |> CALL tvf2(arg2) AS step2"); dialects.verified_stmt( "SELECT * FROM tbl |> CALL preprocess() AS clean_data |> CALL analyze(mode) AS results", ); dialects.verified_stmt( "SELECT * FROM tbl |> CALL transform() |> WHERE status = 'active' |> CALL process(param)", ); dialects.verified_stmt( "SELECT * FROM tbl |> CALL preprocess() AS clean |> SELECT col1, col2 |> CALL validate()", ); } #[test] fn parse_pipe_operator_pivot() { let dialects = all_dialects_where(|d| d.supports_pipe_operator()); dialects.verified_stmt( "SELECT * FROM tbl |> PIVOT(SUM(amount) FOR quarter IN ('Q1', 'Q2', 'Q3', 'Q4'))", ); dialects.verified_stmt( "SELECT * FROM tbl |> PIVOT(AVG(revenue) FOR region IN ('North', 'South', 'East', 'West'))", ); dialects.verified_stmt("SELECT * FROM tbl |> PIVOT(SUM(sales) AS total_sales, COUNT(*) AS num_transactions FOR month IN ('Jan', 'Feb', 'Mar'))"); dialects.verified_stmt("SELECT * FROM tbl |> PIVOT(SUM(amount) FOR product.category IN ('Electronics', 'Clothing'))"); dialects.verified_stmt("SELECT * FROM tbl |> WHERE year = 2023 |> PIVOT(SUM(revenue) FOR quarter IN ('Q1', 'Q2', 'Q3', 'Q4'))"); dialects.verified_stmt( "SELECT * FROM tbl |> PIVOT(SUM(sales) FOR quarter IN ('Q1', 'Q2')) AS quarterly_sales", ); dialects.verified_stmt( "SELECT * FROM tbl |> PIVOT(AVG(price) FOR category IN ('A', 'B', 'C')) AS avg_by_category", ); dialects.verified_stmt("SELECT * FROM tbl |> PIVOT(COUNT(*) AS transactions, SUM(amount) AS total FOR region IN ('North', 'South')) AS regional_summary"); dialects.verified_query_with_canonical( "SELECT * FROM tbl |> PIVOT(SUM(sales) FOR quarter IN ('Q1', 'Q2')) quarterly_sales", "SELECT * FROM tbl |> PIVOT(SUM(sales) FOR quarter IN ('Q1', 'Q2')) AS quarterly_sales", ); dialects.verified_query_with_canonical( "SELECT * FROM tbl |> PIVOT(AVG(price) FOR category IN ('A', 'B', 'C')) avg_by_category", "SELECT * FROM tbl |> PIVOT(AVG(price) FOR category IN ('A', 'B', 'C')) AS avg_by_category", ); } #[test] fn parse_pipe_operator_unpivot() { let dialects = all_dialects_where(|d| d.supports_pipe_operator()); dialects.verified_stmt("SELECT * FROM tbl |> UNPIVOT(revenue FOR quarter IN (Q1, Q2, Q3, Q4))"); dialects.verified_stmt("SELECT * FROM tbl |> UNPIVOT(value FOR category IN (A, B, C))"); dialects.verified_stmt( "SELECT * FROM tbl |> UNPIVOT(measurement FOR metric_type IN (cpu, memory, disk))", ); dialects.verified_stmt( "SELECT * FROM tbl |> UNPIVOT(amount FOR period IN (jan, feb, mar, apr, may, jun))", ); dialects.verified_stmt( "SELECT * FROM tbl |> UNPIVOT(score FOR subject IN (math, science, english, history))", ); dialects.verified_stmt("SELECT * FROM tbl |> WHERE year = 2023 |> UNPIVOT(revenue FOR quarter IN (Q1, Q2, Q3, Q4))"); dialects.verified_stmt( "SELECT * FROM tbl |> UNPIVOT(amount FOR period IN (Q1, Q2)) AS unpivoted_sales", ); dialects.verified_stmt( "SELECT * FROM tbl |> UNPIVOT(value FOR category IN (A, B, C)) AS transformed_data", ); dialects.verified_stmt("SELECT * FROM tbl |> UNPIVOT(measurement FOR metric_type IN (cpu, memory)) AS metric_measurements"); dialects.verified_query_with_canonical( "SELECT * FROM tbl |> UNPIVOT(amount FOR period IN (Q1, Q2)) unpivoted_sales", "SELECT * FROM tbl |> UNPIVOT(amount FOR period IN (Q1, Q2)) AS unpivoted_sales", ); dialects.verified_query_with_canonical( "SELECT * FROM tbl |> UNPIVOT(value FOR category IN (A, B, C)) transformed_data", "SELECT * FROM tbl |> UNPIVOT(value FOR category IN (A, B, C)) AS transformed_data", ); } #[test] fn parse_pipe_operator_join() { let dialects = all_dialects_where(|d| d.supports_pipe_operator()); dialects.verified_stmt("SELECT * FROM tbl |> JOIN orders ON users.id = orders.user_id"); dialects.verified_stmt("SELECT * FROM tbl |> INNER JOIN orders ON users.id = orders.user_id"); dialects.verified_stmt("SELECT * FROM tbl |> LEFT JOIN orders ON users.id = orders.user_id"); dialects .verified_stmt("SELECT * FROM tbl |> LEFT OUTER JOIN orders ON users.id = orders.user_id"); dialects.verified_stmt("SELECT * FROM tbl |> RIGHT JOIN orders ON users.id = orders.user_id"); dialects .verified_stmt("SELECT * FROM tbl |> RIGHT OUTER JOIN orders ON users.id = orders.user_id"); dialects.verified_stmt("SELECT * FROM tbl |> FULL JOIN orders ON users.id = orders.user_id"); dialects.verified_query_with_canonical( "SELECT * FROM tbl |> FULL OUTER JOIN orders ON users.id = orders.user_id", "SELECT * FROM tbl |> FULL JOIN orders ON users.id = orders.user_id", ); dialects.verified_stmt("SELECT * FROM tbl |> CROSS JOIN orders"); dialects.verified_query_with_canonical( "SELECT * FROM tbl |> JOIN orders USING (user_id)", "SELECT * FROM tbl |> JOIN orders USING(user_id)", ); dialects.verified_query_with_canonical( "SELECT * FROM tbl |> LEFT JOIN orders USING (user_id, order_date)", "SELECT * FROM tbl |> LEFT JOIN orders USING(user_id, order_date)", ); dialects.verified_stmt("SELECT * FROM tbl |> JOIN orders o ON users.id = o.user_id"); dialects.verified_stmt("SELECT * FROM tbl |> LEFT JOIN orders AS o ON users.id = o.user_id"); dialects.verified_stmt("SELECT * FROM tbl |> JOIN orders ON users.id = orders.user_id AND orders.status = 'active'"); dialects.verified_stmt("SELECT * FROM tbl |> LEFT JOIN orders ON users.id = orders.user_id AND orders.amount > 100"); dialects.verified_stmt("SELECT * FROM tbl |> JOIN orders ON users.id = orders.user_id |> JOIN products ON orders.product_id = products.id"); dialects.verified_stmt("SELECT * FROM tbl |> LEFT JOIN orders ON users.id = orders.user_id |> RIGHT JOIN products ON orders.product_id = products.id"); dialects.verified_stmt("SELECT * FROM tbl |> JOIN orders ON users.id = orders.user_id |> WHERE orders.amount > 100"); dialects.verified_stmt("SELECT * FROM tbl |> WHERE users.active = true |> LEFT JOIN orders ON users.id = orders.user_id"); dialects.verified_stmt("SELECT * FROM tbl |> JOIN orders ON users.id = orders.user_id |> SELECT users.name, orders.amount"); } #[test] fn parse_pipe_operator_chained() { let dialects = all_dialects_where(|d| d.supports_pipe_operator()); dialects.verified_stmt("SELECT * FROM tbl |> AGGREGATE SUM(cost) AS total_cost GROUP BY customer_id, state, item_type |> EXTEND COUNT(*) OVER (PARTITION BY customer_id) AS num_orders |> WHERE num_orders > 1 |> AGGREGATE AVG(total_cost) AS average GROUP BY state DESC, item_type ASC"); } #[test] fn parse_pipeline_operator_negative_tests() { let dialects = all_dialects_where(|d| d.supports_pipe_operator()); // Test that plain EXCEPT without DISTINCT fails assert_eq!( ParserError::ParserError("EXCEPT pipe operator requires DISTINCT modifier".to_string()), dialects .parse_sql_statements("SELECT * FROM users |> EXCEPT (SELECT * FROM admins)") .unwrap_err() ); // Test that EXCEPT ALL fails assert_eq!( ParserError::ParserError("EXCEPT pipe operator requires DISTINCT modifier".to_string()), dialects .parse_sql_statements("SELECT * FROM users |> EXCEPT ALL (SELECT * FROM admins)") .unwrap_err() ); // Test that EXCEPT BY NAME without DISTINCT fails assert_eq!( ParserError::ParserError("EXCEPT pipe operator requires DISTINCT modifier".to_string()), dialects .parse_sql_statements("SELECT * FROM users |> EXCEPT BY NAME (SELECT * FROM admins)") .unwrap_err() ); // Test that EXCEPT ALL BY NAME fails assert_eq!( ParserError::ParserError("EXCEPT pipe operator requires DISTINCT modifier".to_string()), dialects .parse_sql_statements( "SELECT * FROM users |> EXCEPT ALL BY NAME (SELECT * FROM admins)" ) .unwrap_err() ); // Test that plain INTERSECT without DISTINCT fails assert_eq!( ParserError::ParserError("INTERSECT pipe operator requires DISTINCT modifier".to_string()), dialects .parse_sql_statements("SELECT * FROM users |> INTERSECT (SELECT * FROM admins)") .unwrap_err() ); // Test that INTERSECT ALL fails assert_eq!( ParserError::ParserError("INTERSECT pipe operator requires DISTINCT modifier".to_string()), dialects .parse_sql_statements("SELECT * FROM users |> INTERSECT ALL (SELECT * FROM admins)") .unwrap_err() ); // Test that INTERSECT BY NAME without DISTINCT fails assert_eq!( ParserError::ParserError("INTERSECT pipe operator requires DISTINCT modifier".to_string()), dialects .parse_sql_statements("SELECT * FROM users |> INTERSECT BY NAME (SELECT * FROM admins)") .unwrap_err() ); // Test that INTERSECT ALL BY NAME fails assert_eq!( ParserError::ParserError("INTERSECT pipe operator requires DISTINCT modifier".to_string()), dialects .parse_sql_statements( "SELECT * FROM users |> INTERSECT ALL BY NAME (SELECT * FROM admins)" ) .unwrap_err() ); // Test that CALL without function name fails assert!(dialects .parse_sql_statements("SELECT * FROM users |> CALL") .is_err()); // Test that CALL without parentheses fails assert!(dialects .parse_sql_statements("SELECT * FROM users |> CALL my_function") .is_err()); // Test that CALL with invalid function syntax fails assert!(dialects .parse_sql_statements("SELECT * FROM users |> CALL 123invalid") .is_err()); // Test that CALL with malformed arguments fails assert!(dialects .parse_sql_statements("SELECT * FROM users |> CALL my_function(,)") .is_err()); // Test that CALL with invalid alias syntax fails assert!(dialects .parse_sql_statements("SELECT * FROM users |> CALL my_function() AS") .is_err()); // Test that PIVOT without parentheses fails assert!(dialects .parse_sql_statements("SELECT * FROM users |> PIVOT SUM(amount) FOR month IN ('Jan')") .is_err()); // Test that PIVOT without FOR keyword fails assert!(dialects .parse_sql_statements("SELECT * FROM users |> PIVOT(SUM(amount) month IN ('Jan'))") .is_err()); // Test that PIVOT without IN keyword fails assert!(dialects .parse_sql_statements("SELECT * FROM users |> PIVOT(SUM(amount) FOR month ('Jan'))") .is_err()); // Test that PIVOT with empty IN list fails assert!(dialects .parse_sql_statements("SELECT * FROM users |> PIVOT(SUM(amount) FOR month IN ())") .is_err()); // Test that PIVOT with invalid alias syntax fails assert!(dialects .parse_sql_statements("SELECT * FROM users |> PIVOT(SUM(amount) FOR month IN ('Jan')) AS") .is_err()); // Test UNPIVOT negative cases // Test that UNPIVOT without parentheses fails assert!(dialects .parse_sql_statements("SELECT * FROM users |> UNPIVOT value FOR name IN col1, col2") .is_err()); // Test that UNPIVOT without FOR keyword fails assert!(dialects .parse_sql_statements("SELECT * FROM users |> UNPIVOT(value name IN (col1, col2))") .is_err()); // Test that UNPIVOT without IN keyword fails assert!(dialects .parse_sql_statements("SELECT * FROM users |> UNPIVOT(value FOR name (col1, col2))") .is_err()); // Test that UNPIVOT with missing value column fails assert!(dialects .parse_sql_statements("SELECT * FROM users |> UNPIVOT(FOR name IN (col1, col2))") .is_err()); // Test that UNPIVOT with missing name column fails assert!(dialects .parse_sql_statements("SELECT * FROM users |> UNPIVOT(value FOR IN (col1, col2))") .is_err()); // Test that UNPIVOT with empty IN list fails assert!(dialects .parse_sql_statements("SELECT * FROM users |> UNPIVOT(value FOR name IN ())") .is_err()); // Test that UNPIVOT with invalid alias syntax fails assert!(dialects .parse_sql_statements("SELECT * FROM users |> UNPIVOT(value FOR name IN (col1, col2)) AS") .is_err()); // Test that UNPIVOT with missing closing parenthesis fails assert!(dialects .parse_sql_statements("SELECT * FROM users |> UNPIVOT(value FOR name IN (col1, col2)") .is_err()); // Test that JOIN without table name fails assert!(dialects .parse_sql_statements("SELECT * FROM users |> JOIN ON users.id = orders.user_id") .is_err()); // Test that CROSS JOIN with ON condition fails assert!(dialects .parse_sql_statements( "SELECT * FROM users |> CROSS JOIN orders ON users.id = orders.user_id" ) .is_err()); // Test that CROSS JOIN with USING condition fails assert!(dialects .parse_sql_statements("SELECT * FROM users |> CROSS JOIN orders USING (user_id)") .is_err()); // Test that JOIN with empty USING list fails assert!(dialects .parse_sql_statements("SELECT * FROM users |> JOIN orders USING ()") .is_err()); // Test that JOIN with malformed ON condition fails assert!(dialects .parse_sql_statements("SELECT * FROM users |> JOIN orders ON") .is_err()); // Test that JOIN with invalid USING syntax fails assert!(dialects .parse_sql_statements("SELECT * FROM users |> JOIN orders USING user_id") .is_err()); } #[test] fn parse_multiple_set_statements() -> Result<(), ParserError> { let dialects = all_dialects_where(|d| d.supports_comma_separated_set_assignments()); let stmt = dialects.verified_stmt("SET @a = 1, b = 2"); match stmt { Statement::Set(Set::MultipleAssignments { assignments }) => { assert_eq!( assignments, vec![ SetAssignment { scope: None, name: ObjectName::from(vec!["@a".into()]), value: Expr::value(number("1")) }, SetAssignment { scope: None, name: ObjectName::from(vec!["b".into()]), value: Expr::value(number("2")) } ] ); } _ => panic!("Expected SetVariable with 2 variables and 2 values"), }; let stmt = dialects.verified_stmt("SET GLOBAL @a = 1, SESSION b = 2, LOCAL c = 3, d = 4"); match stmt { Statement::Set(Set::MultipleAssignments { assignments }) => { assert_eq!( assignments, vec![ SetAssignment { scope: Some(ContextModifier::Global), name: ObjectName::from(vec!["@a".into()]), value: Expr::value(number("1")) }, SetAssignment { scope: Some(ContextModifier::Session), name: ObjectName::from(vec!["b".into()]), value: Expr::value(number("2")) }, SetAssignment { scope: Some(ContextModifier::Local), name: ObjectName::from(vec!["c".into()]), value: Expr::value(number("3")) }, SetAssignment { scope: None, name: ObjectName::from(vec!["d".into()]), value: Expr::value(number("4")) } ] ); } _ => panic!("Expected MultipleAssignments with 4 scoped variables and 4 values"), }; Ok(()) } #[test] fn parse_set_time_zone_alias() { match all_dialects().verified_stmt("SET TIME ZONE 'UTC'") { Statement::Set(Set::SetTimeZone { local, value }) => { assert!(!local); assert_eq!( value, Expr::Value((Value::SingleQuotedString("UTC".into())).with_empty_span()) ); } _ => unreachable!(), } } #[test] fn parse_return() { let stmt = all_dialects().verified_stmt("RETURN"); assert_eq!(stmt, Statement::Return(ReturnStatement { value: None })); let _ = all_dialects().verified_stmt("RETURN 1"); } #[test] fn parse_subquery_limit() { let _ = all_dialects().verified_stmt("SELECT t1_id, t1_name FROM t1 WHERE t1_id IN (SELECT t2_id FROM t2 WHERE t1_name = t2_name LIMIT 10)"); } #[test] fn test_open() { let open_cursor = "OPEN Employee_Cursor"; let stmt = all_dialects().verified_stmt(open_cursor); assert_eq!( stmt, Statement::Open(OpenStatement { cursor_name: Ident::new("Employee_Cursor"), }) ); } #[test] fn parse_truncate_only() { let truncate = all_dialects().verified_stmt("TRUNCATE TABLE employee, ONLY dept"); let table_names = vec![ TruncateTableTarget { name: ObjectName::from(vec![Ident::new("employee")]), only: false, has_asterisk: false, }, TruncateTableTarget { name: ObjectName::from(vec![Ident::new("dept")]), only: true, has_asterisk: false, }, ]; assert_eq!( Statement::Truncate(Truncate { table_names, partitions: None, table: true, if_exists: false, identity: None, cascade: None, on_cluster: None, }), truncate ); } #[test] fn check_enforced() { all_dialects().verified_stmt( "CREATE TABLE t (a INT, b INT, c INT, CHECK (a > 0) NOT ENFORCED, CHECK (b > 0) ENFORCED, CHECK (c > 0))", ); } #[test] fn column_check_enforced() { all_dialects().verified_stmt("CREATE TABLE t (x INT CHECK (x > 1) NOT ENFORCED)"); all_dialects().verified_stmt("CREATE TABLE t (x INT CHECK (x > 1) ENFORCED)"); all_dialects().verified_stmt( "CREATE TABLE t (a INT CHECK (a > 0) NOT ENFORCED, b INT CHECK (b > 0) ENFORCED, c INT CHECK (c > 0))", ); } #[test] fn join_precedence() { all_dialects_except(|d| !d.supports_left_associative_joins_without_parens()) .verified_query_with_canonical( "SELECT * FROM t1 NATURAL JOIN t5 INNER JOIN t0 ON (t0.v1 + t5.v0) > 0 WHERE t0.v1 = t1.v0", // canonical string without parentheses "SELECT * FROM t1 NATURAL JOIN t5 INNER JOIN t0 ON (t0.v1 + t5.v0) > 0 WHERE t0.v1 = t1.v0", ); all_dialects_except(|d| d.supports_left_associative_joins_without_parens()).verified_query_with_canonical( "SELECT * FROM t1 NATURAL JOIN t5 INNER JOIN t0 ON (t0.v1 + t5.v0) > 0 WHERE t0.v1 = t1.v0", // canonical string with parentheses "SELECT * FROM t1 NATURAL JOIN (t5 INNER JOIN t0 ON (t0.v1 + t5.v0) > 0) WHERE t0.v1 = t1.v0", ); } #[test] fn parse_create_procedure_with_language() { let sql = r#"CREATE PROCEDURE test_proc LANGUAGE sql AS BEGIN SELECT 1; END"#; match verified_stmt(sql) { Statement::CreateProcedure { or_alter, name, params, language, .. } => { assert_eq!(or_alter, false); assert_eq!(name.to_string(), "test_proc"); assert_eq!(params, Some(vec![])); assert_eq!( language, Some(Ident { value: "sql".into(), quote_style: None, span: Span { start: Location::empty(), end: Location::empty() } }) ); } _ => unreachable!(), } } #[test] fn parse_create_procedure_with_parameter_modes() { let sql = r#"CREATE PROCEDURE test_proc (IN a INTEGER, OUT b TEXT, INOUT c TIMESTAMP, d BOOL) AS BEGIN SELECT 1; END"#; match verified_stmt(sql) { Statement::CreateProcedure { or_alter, name, params, .. } => { assert_eq!(or_alter, false); assert_eq!(name.to_string(), "test_proc"); let fake_span = Span { start: Location { line: 0, column: 0 }, end: Location { line: 0, column: 0 }, }; assert_eq!( params, Some(vec![ ProcedureParam { name: Ident { value: "a".into(), quote_style: None, span: fake_span, }, data_type: DataType::Integer(None), mode: Some(ArgMode::In), default: None, }, ProcedureParam { name: Ident { value: "b".into(), quote_style: None, span: fake_span, }, data_type: DataType::Text, mode: Some(ArgMode::Out), default: None, }, ProcedureParam { name: Ident { value: "c".into(), quote_style: None, span: fake_span, }, data_type: DataType::Timestamp(None, TimezoneInfo::None), mode: Some(ArgMode::InOut), default: None, }, ProcedureParam { name: Ident { value: "d".into(), quote_style: None, span: fake_span, }, data_type: DataType::Bool, mode: None, default: None, }, ]) ); } _ => unreachable!(), } // parameters with default values let sql = r#"CREATE PROCEDURE test_proc (IN a INTEGER = 1, OUT b TEXT = '2', INOUT c TIMESTAMP = NULL, d BOOL = 0) AS BEGIN SELECT 1; END"#; match verified_stmt(sql) { Statement::CreateProcedure { or_alter, name, params, .. } => { assert_eq!(or_alter, false); assert_eq!(name.to_string(), "test_proc"); assert_eq!( params, Some(vec![ ProcedureParam { name: Ident::new("a"), data_type: DataType::Integer(None), mode: Some(ArgMode::In), default: Some(Expr::Value((number("1")).with_empty_span())), }, ProcedureParam { name: Ident::new("b"), data_type: DataType::Text, mode: Some(ArgMode::Out), default: Some(Expr::Value( Value::SingleQuotedString("2".into()).with_empty_span() )), }, ProcedureParam { name: Ident::new("c"), data_type: DataType::Timestamp(None, TimezoneInfo::None), mode: Some(ArgMode::InOut), default: Some(Expr::Value(Value::Null.with_empty_span())), }, ProcedureParam { name: Ident::new("d"), data_type: DataType::Bool, mode: None, default: Some(Expr::Value((number("0")).with_empty_span())), } ]), ); } _ => unreachable!(), } } #[test] fn parse_not_null() { let _ = all_dialects().expr_parses_to("x NOT NULL", "x IS NOT NULL"); let _ = all_dialects().expr_parses_to("NULL NOT NULL", "NULL IS NOT NULL"); assert_matches!( all_dialects().expr_parses_to("NOT NULL NOT NULL", "NOT NULL IS NOT NULL"), Expr::UnaryOp { op: UnaryOperator::Not, .. } ); assert_matches!( all_dialects().expr_parses_to("NOT x NOT NULL", "NOT x IS NOT NULL"), Expr::UnaryOp { op: UnaryOperator::Not, .. } ); } #[test] fn test_select_exclude() { let dialects = all_dialects_where(|d| d.supports_select_wildcard_exclude()); match &dialects .verified_only_select("SELECT * EXCLUDE c1 FROM test") .projection[0] { SelectItem::Wildcard(WildcardAdditionalOptions { opt_exclude, .. }) => { assert_eq!( *opt_exclude, Some(ExcludeSelectItem::Single(ObjectName::from(Ident::new( "c1" )))) ); } _ => unreachable!(), } match &dialects .verified_only_select("SELECT * EXCLUDE (c1, c2) FROM test") .projection[0] { SelectItem::Wildcard(WildcardAdditionalOptions { opt_exclude, .. }) => { assert_eq!( *opt_exclude, Some(ExcludeSelectItem::Multiple(vec![ ObjectName::from(Ident::new("c1")), ObjectName::from(Ident::new("c2")), ])) ); } _ => unreachable!(), } let select = dialects.verified_only_select("SELECT * EXCLUDE c1, c2 FROM test"); match &select.projection[0] { SelectItem::Wildcard(WildcardAdditionalOptions { opt_exclude, .. }) => { assert_eq!( *opt_exclude, Some(ExcludeSelectItem::Single(ObjectName::from(Ident::new( "c1" )))) ); } _ => unreachable!(), } match &select.projection[1] { SelectItem::UnnamedExpr(Expr::Identifier(ident)) => { assert_eq!(*ident, Ident::new("c2")); } _ => unreachable!(), } let dialects = all_dialects_where(|d| d.supports_select_exclude()); let select = dialects.verified_only_select("SELECT *, c1 EXCLUDE c1 FROM test"); match &select.projection[0] { SelectItem::Wildcard(additional_options) => { assert_eq!(*additional_options, WildcardAdditionalOptions::default()); } _ => unreachable!(), } assert_eq!( select.exclude, Some(ExcludeSelectItem::Single(ObjectName::from(Ident::new( "c1" )))) ); let dialects = all_dialects_where(|d| { d.supports_select_wildcard_exclude() && !d.supports_select_exclude() }); let select = dialects.verified_only_select("SELECT * EXCLUDE c1 FROM test"); match &select.projection[0] { SelectItem::Wildcard(WildcardAdditionalOptions { opt_exclude, .. }) => { assert_eq!( *opt_exclude, Some(ExcludeSelectItem::Single(ObjectName::from(Ident::new( "c1" )))) ); } _ => unreachable!(), } // Dialects that only support the wildcard form and do not accept EXCLUDE as an implicity alias // will fail when encountered with the `c2` ident let dialects = all_dialects_where(|d| { d.supports_select_wildcard_exclude() && !d.supports_select_exclude() && d.is_column_alias(&Keyword::EXCLUDE, &mut Parser::new(d)) }); assert_eq!( dialects .parse_sql_statements("SELECT *, c1 EXCLUDE c2 FROM test") .err() .unwrap(), ParserError::ParserError("Expected: end of statement, found: c2".to_string()) ); // Dialects that only support the wildcard form and accept EXCLUDE as an implicity alias // will fail when encountered with the `EXCLUDE` keyword let dialects = all_dialects_where(|d| { d.supports_select_wildcard_exclude() && !d.supports_select_exclude() && !d.is_column_alias(&Keyword::EXCLUDE, &mut Parser::new(d)) }); assert_eq!( dialects .parse_sql_statements("SELECT *, c1 EXCLUDE c2 FROM test") .err() .unwrap(), ParserError::ParserError("Expected: end of statement, found: EXCLUDE".to_string()) ); } #[test] fn test_select_exclude_qualified_names() { // EXCLUDE should accept qualified names like `f.col` parsed as ObjectName. let dialects = all_dialects_where(|d| d.supports_select_wildcard_exclude()); // Qualified name in multi-column EXCLUDE list: f.* EXCLUDE (f.col1, f.col2) let select = dialects .verified_only_select("SELECT f.* EXCLUDE (f.account_canonical_id, f.amount) FROM t AS f"); match &select.projection[0] { SelectItem::QualifiedWildcard(_, WildcardAdditionalOptions { opt_exclude, .. }) => { assert_eq!( *opt_exclude, Some(ExcludeSelectItem::Multiple(vec![ ObjectName::from(vec![Ident::new("f"), Ident::new("account_canonical_id")]), ObjectName::from(vec![Ident::new("f"), Ident::new("amount")]), ])) ); } _ => unreachable!(), } // Plain identifiers must still parse successfully. dialects.verified_only_select("SELECT f.* EXCLUDE (account_canonical_id) FROM t AS f"); dialects.verified_only_select("SELECT f.* EXCLUDE (col1, col2) FROM t AS f"); } #[test] fn test_no_semicolon_required_between_statements() { let sql = r#" SELECT * FROM tbl1 SELECT * FROM tbl2 "#; let dialects = all_dialects_with_options(ParserOptions { trailing_commas: false, unescape: true, require_semicolon_stmt_delimiter: false, }); let stmts = dialects.parse_sql_statements(sql).unwrap(); assert_eq!(stmts.len(), 2); assert!(stmts.iter().all(|s| matches!(s, Statement::Query { .. }))); } #[test] fn test_identifier_unicode_support() { let sql = r#"SELECT phoneǤЖשचᎯ⻩☯♜🦄⚛🀄ᚠ⌛🌀 AS tbl FROM customers"#; let dialects = TestedDialects::new(vec![ Box::new(MySqlDialect {}), Box::new(RedshiftSqlDialect {}), Box::new(PostgreSqlDialect {}), ]); let _ = dialects.verified_stmt(sql); } #[test] fn test_identifier_unicode_start() { let sql = r#"SELECT 💝phone AS 💝 FROM customers"#; let dialects = TestedDialects::new(vec![ Box::new(MySqlDialect {}), Box::new(RedshiftSqlDialect {}), Box::new(PostgreSqlDialect {}), ]); let _ = dialects.verified_stmt(sql); } #[test] fn parse_notnull() { // Some dialects support `x NOTNULL` as an expression while others consider // `x NOTNULL` like `x AS NOTNULL` and thus consider `NOTNULL` an alias for x. let notnull_unsupported_dialects = all_dialects_except(|d| d.supports_notnull_operator()); let _ = notnull_unsupported_dialects .verified_only_select_with_canonical("SELECT NULL NOTNULL", "SELECT NULL AS NOTNULL"); // Supported dialects consider `x NOTNULL` as an alias for `x IS NOT NULL` let notnull_supported_dialects = all_dialects_where(|d| d.supports_notnull_operator()); let _ = notnull_supported_dialects.expr_parses_to("x NOTNULL", "x IS NOT NULL"); // For dialects which support it, `NOT NULL NOTNULL` should // parse as `(NOT (NULL IS NOT NULL))` assert_matches!( notnull_supported_dialects.expr_parses_to("NOT NULL NOTNULL", "NOT NULL IS NOT NULL"), Expr::UnaryOp { op: UnaryOperator::Not, .. } ); // for unsupported dialects, parsing should stop at `NOT NULL` notnull_unsupported_dialects.expr_parses_to("NOT NULL NOTNULL", "NOT NULL"); } #[test] fn parse_odbc_time_date_timestamp() { // Supported statements let sql_d = "SELECT {d '2025-07-17'}, category_name FROM categories"; let _ = all_dialects().verified_stmt(sql_d); let sql_t = "SELECT {t '14:12:01'}, category_name FROM categories"; let _ = all_dialects().verified_stmt(sql_t); let sql_ts = "SELECT {ts '2025-07-17 14:12:01'}, category_name FROM categories"; let _ = all_dialects().verified_stmt(sql_ts); // Unsupported statement let supports_dictionary = all_dialects_where(|d| d.supports_dictionary_syntax()); let dictionary_unsupported = all_dialects_where(|d| !d.supports_dictionary_syntax()); let sql = "SELECT {tt '14:12:01'} FROM foo"; let res = supports_dictionary.parse_sql_statements(sql); let res_dict = dictionary_unsupported.parse_sql_statements(sql); assert_eq!( ParserError::ParserError("Expected: :, found: '14:12:01'".to_string()), res.unwrap_err() ); assert_eq!( ParserError::ParserError("Expected: an expression, found: {".to_string()), res_dict.unwrap_err() ); } #[test] fn parse_create_user() { let create = verified_stmt("CREATE USER u1"); match create { Statement::CreateUser(stmt) => { assert_eq!(stmt.name, Ident::new("u1")); } _ => unreachable!(), } verified_stmt("CREATE OR REPLACE USER u1"); verified_stmt("CREATE OR REPLACE USER IF NOT EXISTS u1"); verified_stmt("CREATE OR REPLACE USER IF NOT EXISTS u1 PASSWORD='secret'"); let dialects = all_dialects_where(|d| d.supports_boolean_literals()); dialects.one_statement_parses_to( "CREATE OR REPLACE USER IF NOT EXISTS u1 PASSWORD='secret' MUST_CHANGE_PASSWORD=TRUE", "CREATE OR REPLACE USER IF NOT EXISTS u1 PASSWORD='secret' MUST_CHANGE_PASSWORD=true", ); dialects.verified_stmt("CREATE OR REPLACE USER IF NOT EXISTS u1 PASSWORD='secret' MUST_CHANGE_PASSWORD=true TYPE=SERVICE TAG (t1='v1')"); let create = dialects.verified_stmt("CREATE OR REPLACE USER IF NOT EXISTS u1 PASSWORD='secret' MUST_CHANGE_PASSWORD=false TYPE=SERVICE WITH TAG (t1='v1', t2='v2')"); match create { Statement::CreateUser(stmt) => { assert_eq!(stmt.name, Ident::new("u1")); assert_eq!(stmt.or_replace, true); assert_eq!(stmt.if_not_exists, true); assert_eq!( stmt.options, KeyValueOptions { delimiter: KeyValueOptionsDelimiter::Space, options: vec![ KeyValueOption { option_name: "PASSWORD".to_string(), option_value: KeyValueOptionKind::Single( Value::SingleQuotedString("secret".to_string()).with_empty_span() ), }, KeyValueOption { option_name: "MUST_CHANGE_PASSWORD".to_string(), option_value: KeyValueOptionKind::Single( Value::Boolean(false).with_empty_span() ), }, KeyValueOption { option_name: "TYPE".to_string(), option_value: KeyValueOptionKind::Single( Value::Placeholder("SERVICE".to_string()).with_empty_span() ), }, ], }, ); assert_eq!(stmt.with_tags, true); assert_eq!( stmt.tags, KeyValueOptions { delimiter: KeyValueOptionsDelimiter::Comma, options: vec![ KeyValueOption { option_name: "t1".to_string(), option_value: KeyValueOptionKind::Single( Value::SingleQuotedString("v1".to_string()).with_empty_span() ), }, KeyValueOption { option_name: "t2".to_string(), option_value: KeyValueOptionKind::Single( Value::SingleQuotedString("v2".to_string()).with_empty_span() ), }, ] } ); } _ => unreachable!(), } } #[test] fn parse_drop_stream() { let sql = "DROP STREAM s1"; match verified_stmt(sql) { Statement::Drop { names, object_type, .. } => { assert_eq!( vec!["s1"], names.iter().map(ToString::to_string).collect::>() ); assert_eq!(ObjectType::Stream, object_type); } _ => unreachable!(), } verified_stmt("DROP STREAM IF EXISTS s1"); } #[test] fn parse_create_view_if_not_exists() { // Name after IF NOT EXISTS let sql: &'static str = "CREATE VIEW IF NOT EXISTS v AS SELECT 1"; let _ = all_dialects().verified_stmt(sql); // Name before IF NOT EXISTS let sql = "CREATE VIEW v IF NOT EXISTS AS SELECT 1"; let _ = all_dialects().verified_stmt(sql); // Name missing from query let sql = "CREATE VIEW IF NOT EXISTS AS SELECT 1"; let res = all_dialects().parse_sql_statements(sql); assert_eq!( ParserError::ParserError("Expected: AS, found: SELECT".to_string()), res.unwrap_err() ); } #[test] fn test_parse_not_null_in_column_options() { let canonical = concat!( "CREATE TABLE foo (", "abc INT DEFAULT (42 IS NOT NULL) NOT NULL,", " def INT,", " def_null BOOL GENERATED ALWAYS AS (def IS NOT NULL) STORED,", " CHECK (abc IS NOT NULL)", ")" ); all_dialects().verified_stmt(canonical); all_dialects().one_statement_parses_to( concat!( "CREATE TABLE foo (", "abc INT DEFAULT (42 NOT NULL) NOT NULL,", " def INT,", " def_null BOOL GENERATED ALWAYS AS (def NOT NULL) STORED,", " CHECK (abc NOT NULL)", ")" ), canonical, ); } #[test] fn test_parse_default_expr_with_operators() { all_dialects().verified_stmt("CREATE TABLE t (c INT DEFAULT (1 + 2) + 3)"); all_dialects().verified_stmt("CREATE TABLE t (c INT DEFAULT (1 + 2) + 3 NOT NULL)"); } #[test] fn test_parse_default_with_collate_column_option() { let sql = "CREATE TABLE foo (abc TEXT DEFAULT 'foo' COLLATE 'en_US')"; let stmt = all_dialects().verified_stmt(sql); if let Statement::CreateTable(CreateTable { mut columns, .. }) = stmt { let mut column = columns.pop().unwrap(); assert_eq!(&column.name.value, "abc"); assert_eq!(column.data_type, DataType::Text); let collate_option = column.options.pop().unwrap(); if let ColumnOptionDef { name: None, option: ColumnOption::Collation(collate), } = collate_option { assert_eq!(collate.to_string(), "'en_US'"); } else { panic!("Expected collate column option, got {collate_option}"); } let default_option = column.options.pop().unwrap(); if let ColumnOptionDef { name: None, option: ColumnOption::Default(Expr::Value(value)), } = default_option { assert_eq!(value.to_string(), "'foo'"); } else { panic!("Expected default column option, got {default_option}"); } } else { panic!("Expected create table statement"); } } #[test] fn parse_create_table_like() { let dialects = all_dialects_except(|d| d.supports_create_table_like_parenthesized()); let sql = "CREATE TABLE new LIKE old"; match dialects.verified_stmt(sql) { Statement::CreateTable(stmt) => { assert_eq!( stmt.name, ObjectName::from(vec![Ident::new("new".to_string())]) ); assert_eq!( stmt.like, Some(CreateTableLikeKind::Plain(CreateTableLike { name: ObjectName::from(vec![Ident::new("old".to_string())]), defaults: None, })) ) } _ => unreachable!(), } let dialects = all_dialects_where(|d| d.supports_create_table_like_parenthesized()); let sql = "CREATE TABLE new (LIKE old)"; match dialects.verified_stmt(sql) { Statement::CreateTable(stmt) => { assert_eq!( stmt.name, ObjectName::from(vec![Ident::new("new".to_string())]) ); assert_eq!( stmt.like, Some(CreateTableLikeKind::Parenthesized(CreateTableLike { name: ObjectName::from(vec![Ident::new("old".to_string())]), defaults: None, })) ) } _ => unreachable!(), } let sql = "CREATE TABLE new (LIKE old INCLUDING DEFAULTS)"; match dialects.verified_stmt(sql) { Statement::CreateTable(stmt) => { assert_eq!( stmt.name, ObjectName::from(vec![Ident::new("new".to_string())]) ); assert_eq!( stmt.like, Some(CreateTableLikeKind::Parenthesized(CreateTableLike { name: ObjectName::from(vec![Ident::new("old".to_string())]), defaults: Some(CreateTableLikeDefaults::Including), })) ) } _ => unreachable!(), } let sql = "CREATE TABLE new (LIKE old EXCLUDING DEFAULTS)"; match dialects.verified_stmt(sql) { Statement::CreateTable(stmt) => { assert_eq!( stmt.name, ObjectName::from(vec![Ident::new("new".to_string())]) ); assert_eq!( stmt.like, Some(CreateTableLikeKind::Parenthesized(CreateTableLike { name: ObjectName::from(vec![Ident::new("old".to_string())]), defaults: Some(CreateTableLikeDefaults::Excluding), })) ) } _ => unreachable!(), } } #[test] fn parse_copy_options() { let copy = verified_stmt( r#"COPY dst (c1, c2, c3) FROM 's3://redshift-downloads/tickit/category_pipe.txt' IAM_ROLE 'arn:aws:iam::123456789:role/role1' CSV IGNOREHEADER 1"#, ); match copy { Statement::Copy { legacy_options, .. } => { assert_eq!( legacy_options, vec![ CopyLegacyOption::IamRole(IamRoleKind::Arn( "arn:aws:iam::123456789:role/role1".to_string() )), CopyLegacyOption::Csv(vec![]), CopyLegacyOption::IgnoreHeader(1), ] ); } _ => unreachable!(), } let copy = one_statement_parses_to( r#"COPY dst (c1, c2, c3) FROM 's3://redshift-downloads/tickit/category_pipe.txt' IAM_ROLE DEFAULT CSV IGNOREHEADER AS 1"#, r#"COPY dst (c1, c2, c3) FROM 's3://redshift-downloads/tickit/category_pipe.txt' IAM_ROLE DEFAULT CSV IGNOREHEADER 1"#, ); match copy { Statement::Copy { legacy_options, .. } => { assert_eq!( legacy_options, vec![ CopyLegacyOption::IamRole(IamRoleKind::Default), CopyLegacyOption::Csv(vec![]), CopyLegacyOption::IgnoreHeader(1), ] ); } _ => unreachable!(), } one_statement_parses_to( concat!( "COPY dst (c1, c2, c3) FROM 's3://redshift-downloads/tickit/category_pipe.txt' ", "ACCEPTANYDATE ", "ACCEPTINVCHARS AS '*' ", "BLANKSASNULL ", "CSV ", "DATEFORMAT AS 'DD-MM-YYYY' ", "EMPTYASNULL ", "IAM_ROLE DEFAULT ", "IGNOREHEADER AS 1 ", "JSON ", "JSON 'auto' ", "JSON AS 'auto' ", "TIMEFORMAT AS 'auto' ", "TRUNCATECOLUMNS ", "REMOVEQUOTES ", "COMPUPDATE ", "COMPUPDATE PRESET ", "COMPUPDATE ON ", "COMPUPDATE OFF ", "COMPUPDATE TRUE ", "COMPUPDATE FALSE ", "STATUPDATE ", "STATUPDATE ON ", "STATUPDATE OFF ", "STATUPDATE TRUE ", "STATUPDATE FALSE", ), concat!( "COPY dst (c1, c2, c3) FROM 's3://redshift-downloads/tickit/category_pipe.txt' ", "ACCEPTANYDATE ", "ACCEPTINVCHARS '*' ", "BLANKSASNULL ", "CSV ", "DATEFORMAT 'DD-MM-YYYY' ", "EMPTYASNULL ", "IAM_ROLE DEFAULT ", "IGNOREHEADER 1 ", "JSON ", "JSON AS 'auto' ", "JSON AS 'auto' ", "TIMEFORMAT 'auto' ", "TRUNCATECOLUMNS ", "REMOVEQUOTES ", "COMPUPDATE ", "COMPUPDATE PRESET ", "COMPUPDATE TRUE ", "COMPUPDATE FALSE ", "COMPUPDATE TRUE ", "COMPUPDATE FALSE ", "STATUPDATE ", "STATUPDATE TRUE ", "STATUPDATE FALSE ", "STATUPDATE TRUE ", "STATUPDATE FALSE", ), ); one_statement_parses_to( "COPY dst (c1, c2, c3) FROM 's3://redshift-downloads/tickit/category_pipe.txt' FORMAT AS CSV", "COPY dst (c1, c2, c3) FROM 's3://redshift-downloads/tickit/category_pipe.txt' CSV", ); } #[test] fn test_parse_semantic_view_table_factor() { let dialects = all_dialects_where(|d| d.supports_semantic_view_table_factor()); let valid_sqls = [ ("SELECT * FROM SEMANTIC_VIEW(model)", None), ( "SELECT * FROM SEMANTIC_VIEW(model DIMENSIONS dim1, dim2)", None, ), ("SELECT * FROM SEMANTIC_VIEW(a.b METRICS c.d, c.e)", None), ( "SELECT * FROM SEMANTIC_VIEW(model FACTS fact1, fact2)", None, ), ( "SELECT * FROM SEMANTIC_VIEW(model FACTS DATE_PART('year', col))", None, ), ( "SELECT * FROM SEMANTIC_VIEW(model DIMENSIONS dim1 METRICS met1)", None, ), ( "SELECT * FROM SEMANTIC_VIEW(model DIMENSIONS dim1 WHERE x > 0)", None, ), ( "SELECT * FROM SEMANTIC_VIEW(model DIMENSIONS dim1) AS sv", None, ), ( "SELECT * FROM SEMANTIC_VIEW(model DIMENSIONS DATE_PART('year', col))", None, ), ( "SELECT * FROM SEMANTIC_VIEW(model METRICS orders.col, orders.col2)", None, ), ("SELECT * FROM SEMANTIC_VIEW(model METRICS orders.*)", None), ("SELECT * FROM SEMANTIC_VIEW(model FACTS fact.*)", None), ( "SELECT * FROM SEMANTIC_VIEW(model DIMENSIONS dim.* METRICS orders.*)", None, ), // We can parse in any order but will always produce a result in a fixed order. ( "SELECT * FROM SEMANTIC_VIEW(model WHERE x > 0 DIMENSIONS dim1)", Some("SELECT * FROM SEMANTIC_VIEW(model DIMENSIONS dim1 WHERE x > 0)"), ), ( "SELECT * FROM SEMANTIC_VIEW(model METRICS met1 DIMENSIONS dim1)", Some("SELECT * FROM SEMANTIC_VIEW(model DIMENSIONS dim1 METRICS met1)"), ), ( "SELECT * FROM SEMANTIC_VIEW(model FACTS fact1 DIMENSIONS dim1)", Some("SELECT * FROM SEMANTIC_VIEW(model DIMENSIONS dim1 FACTS fact1)"), ), ]; for (input_sql, expected_sql) in valid_sqls { if let Some(expected) = expected_sql { // Test that non-canonical order gets normalized let parsed = dialects.parse_sql_statements(input_sql).unwrap(); let formatted = parsed[0].to_string(); assert_eq!(formatted, expected); } else { dialects.verified_stmt(input_sql); } } let invalid_sqls = [ "SELECT * FROM SEMANTIC_VIEW(model DIMENSIONS dim1 INVALID inv1)", "SELECT * FROM SEMANTIC_VIEW(model DIMENSIONS dim1 DIMENSIONS dim2)", ]; for sql in invalid_sqls { let result = dialects.parse_sql_statements(sql); assert!(result.is_err(), "Expected error for invalid SQL: {sql}"); } let ast_sql = r#"SELECT * FROM SEMANTIC_VIEW( my_model DIMENSIONS DATE_PART('year', date_col), region_name METRICS orders.revenue, orders.count WHERE active = true ) AS model_alias"#; let stmt = dialects.parse_sql_statements(ast_sql).unwrap(); match &stmt[0] { Statement::Query(q) => { if let SetExpr::Select(select) = q.body.as_ref() { if let Some(TableWithJoins { relation, .. }) = select.from.first() { match relation { TableFactor::SemanticView { name, dimensions, metrics, facts, where_clause, alias, } => { assert_eq!(name.to_string(), "my_model"); assert_eq!(dimensions.len(), 2); assert_eq!(dimensions[0].to_string(), "DATE_PART('year', date_col)"); assert_eq!(dimensions[1].to_string(), "region_name"); assert_eq!(metrics.len(), 2); assert_eq!(metrics[0].to_string(), "orders.revenue"); assert_eq!(metrics[1].to_string(), "orders.count"); assert!(facts.is_empty()); assert!(where_clause.is_some()); assert_eq!(where_clause.as_ref().unwrap().to_string(), "active = true"); assert!(alias.is_some()); assert_eq!(alias.as_ref().unwrap().name.value, "model_alias"); } _ => panic!("Expected SemanticView table factor"), } } else { panic!("Expected table in FROM clause"); } } else { panic!("Expected SELECT statement"); } } _ => panic!("Expected Query statement"), } } #[test] fn parse_adjacent_string_literal_concatenation() { let sql = r#"SELECT 'M' 'y' 'S' 'q' 'l'"#; let dialects = all_dialects_where(|d| d.supports_string_literal_concatenation()); dialects.one_statement_parses_to(sql, r"SELECT 'MySql'"); let sql = "SELECT * FROM t WHERE col = 'Hello' \n ' ' \t 'World!'"; dialects.one_statement_parses_to(sql, r"SELECT * FROM t WHERE col = 'Hello World!'"); let dialects = all_dialects_where(|d| d.supports_string_literal_concatenation_with_newline()); let sql = r#" SELECT 'abc' in ('a' 'b' 'c', 'd' )"#; dialects.one_statement_parses_to(sql, "SELECT 'abc' IN ('abc', 'd')"); let sql = r#" SELECT 'abc' in ('a' 'b' -- COMMENT 'c', -- COMMENT 'd' )"#; dialects.one_statement_parses_to(sql, "SELECT 'abc' IN ('abc', 'd')"); } #[test] fn parse_invisible_column() { let sql = r#"CREATE TABLE t (foo INT, bar INT INVISIBLE)"#; let stmt = verified_stmt(sql); match stmt { Statement::CreateTable(CreateTable { columns, .. }) => { assert_eq!( columns, vec![ ColumnDef { name: "foo".into(), data_type: DataType::Int(None), options: vec![] }, ColumnDef { name: "bar".into(), data_type: DataType::Int(None), options: vec![ColumnOptionDef { name: None, option: ColumnOption::Invisible }] } ] ); } _ => panic!("Unexpected statement {stmt}"), } let sql = r#"ALTER TABLE t ADD COLUMN bar INT INVISIBLE"#; let stmt = verified_stmt(sql); match stmt { Statement::AlterTable(alter_table) => { assert_eq!( alter_table.operations, vec![AlterTableOperation::AddColumn { column_keyword: true, if_not_exists: false, column_def: ColumnDef { name: "bar".into(), data_type: DataType::Int(None), options: vec![ColumnOptionDef { name: None, option: ColumnOption::Invisible }] }, column_position: None }] ); } _ => panic!("Unexpected statement {stmt}"), } } #[test] fn parse_create_index_different_using_positions() { let sql = "CREATE INDEX idx_name USING BTREE ON table_name (col1)"; let expected = "CREATE INDEX idx_name ON table_name USING BTREE (col1)"; match all_dialects().one_statement_parses_to(sql, expected) { Statement::CreateIndex(CreateIndex { name, table_name, using, columns, unique, .. }) => { assert_eq!(name.unwrap().to_string(), "idx_name"); assert_eq!(table_name.to_string(), "table_name"); assert_eq!(using, Some(IndexType::BTree)); assert_eq!(columns.len(), 1); assert!(!unique); } _ => unreachable!(), } let sql = "CREATE INDEX idx_name USING BTREE ON table_name (col1) USING HASH"; let expected = "CREATE INDEX idx_name ON table_name USING BTREE (col1) USING HASH"; match all_dialects().one_statement_parses_to(sql, expected) { Statement::CreateIndex(CreateIndex { name, table_name, columns, index_options, .. }) => { assert_eq!(name.unwrap().to_string(), "idx_name"); assert_eq!(table_name.to_string(), "table_name"); assert_eq!(columns.len(), 1); assert!(index_options .iter() .any(|o| o == &IndexOption::Using(IndexType::Hash))); } _ => unreachable!(), } } #[test] fn test_parse_alter_user() { verified_stmt("ALTER USER u1"); verified_stmt("ALTER USER IF EXISTS u1"); let stmt = verified_stmt("ALTER USER IF EXISTS u1 RENAME TO u2"); match stmt { Statement::AlterUser(alter) => { assert!(alter.if_exists); assert_eq!(alter.name, Ident::new("u1")); assert_eq!(alter.rename_to, Some(Ident::new("u2"))); } _ => unreachable!(), } verified_stmt("ALTER USER IF EXISTS u1 RESET PASSWORD"); verified_stmt("ALTER USER IF EXISTS u1 ABORT ALL QUERIES"); verified_stmt( "ALTER USER IF EXISTS u1 ADD DELEGATED AUTHORIZATION OF ROLE r1 TO SECURITY INTEGRATION i1", ); verified_stmt("ALTER USER IF EXISTS u1 REMOVE DELEGATED AUTHORIZATION OF ROLE r1 FROM SECURITY INTEGRATION i1"); verified_stmt( "ALTER USER IF EXISTS u1 REMOVE DELEGATED AUTHORIZATIONS FROM SECURITY INTEGRATION i1", ); verified_stmt("ALTER USER IF EXISTS u1 ENROLL MFA"); let stmt = verified_stmt("ALTER USER u1 SET DEFAULT_MFA_METHOD PASSKEY"); match stmt { Statement::AlterUser(alter) => { assert_eq!(alter.set_default_mfa_method, Some(MfaMethodKind::PassKey)) } _ => unreachable!(), } verified_stmt("ALTER USER u1 SET DEFAULT_MFA_METHOD TOTP"); verified_stmt("ALTER USER u1 SET DEFAULT_MFA_METHOD DUO"); let stmt = verified_stmt("ALTER USER u1 REMOVE MFA METHOD PASSKEY"); match stmt { Statement::AlterUser(alter) => { assert_eq!(alter.remove_mfa_method, Some(MfaMethodKind::PassKey)) } _ => unreachable!(), } verified_stmt("ALTER USER u1 REMOVE MFA METHOD TOTP"); verified_stmt("ALTER USER u1 REMOVE MFA METHOD DUO"); let stmt = verified_stmt("ALTER USER u1 MODIFY MFA METHOD PASSKEY SET COMMENT 'abc'"); match stmt { Statement::AlterUser(alter) => { assert_eq!( alter.modify_mfa_method, Some(AlterUserModifyMfaMethod { method: MfaMethodKind::PassKey, comment: "abc".to_string() }) ); } _ => unreachable!(), } verified_stmt("ALTER USER u1 ADD MFA METHOD OTP"); verified_stmt("ALTER USER u1 ADD MFA METHOD OTP COUNT = 8"); let stmt = verified_stmt("ALTER USER u1 SET AUTHENTICATION POLICY p1"); match stmt { Statement::AlterUser(alter) => { assert_eq!( alter.set_policy, Some(AlterUserSetPolicy { policy_kind: UserPolicyKind::Authentication, policy: Ident::new("p1") }) ); } _ => unreachable!(), } verified_stmt("ALTER USER u1 SET PASSWORD POLICY p1"); verified_stmt("ALTER USER u1 SET SESSION POLICY p1"); let stmt = verified_stmt("ALTER USER u1 UNSET AUTHENTICATION POLICY"); match stmt { Statement::AlterUser(alter) => { assert_eq!(alter.unset_policy, Some(UserPolicyKind::Authentication)); } _ => unreachable!(), } verified_stmt("ALTER USER u1 UNSET PASSWORD POLICY"); verified_stmt("ALTER USER u1 UNSET SESSION POLICY"); let stmt = verified_stmt("ALTER USER u1 SET TAG k1='v1'"); match stmt { Statement::AlterUser(alter) => { assert_eq!( alter.set_tag.options, vec![KeyValueOption { option_name: "k1".to_string(), option_value: KeyValueOptionKind::Single( Value::SingleQuotedString("v1".to_string()).with_empty_span() ), },] ); } _ => unreachable!(), } verified_stmt("ALTER USER u1 SET TAG k1='v1', k2='v2'"); let stmt = verified_stmt("ALTER USER u1 UNSET TAG k1"); match stmt { Statement::AlterUser(alter) => { assert_eq!(alter.unset_tag, vec!["k1".to_string()]); } _ => unreachable!(), } verified_stmt("ALTER USER u1 UNSET TAG k1, k2, k3"); let dialects = all_dialects_where(|d| d.supports_boolean_literals()); dialects.one_statement_parses_to( "ALTER USER u1 SET PASSWORD='secret', MUST_CHANGE_PASSWORD=TRUE, MINS_TO_UNLOCK=10", "ALTER USER u1 SET PASSWORD='secret', MUST_CHANGE_PASSWORD=true, MINS_TO_UNLOCK=10", ); let stmt = dialects.verified_stmt( "ALTER USER u1 SET PASSWORD='secret', MUST_CHANGE_PASSWORD=true, MINS_TO_UNLOCK=10", ); match stmt { Statement::AlterUser(alter) => { assert_eq!( alter.set_props, KeyValueOptions { delimiter: KeyValueOptionsDelimiter::Comma, options: vec![ KeyValueOption { option_name: "PASSWORD".to_string(), option_value: KeyValueOptionKind::Single( Value::SingleQuotedString("secret".to_string()).with_empty_span() ), }, KeyValueOption { option_name: "MUST_CHANGE_PASSWORD".to_string(), option_value: KeyValueOptionKind::Single( Value::Boolean(true).with_empty_span() ), }, KeyValueOption { option_name: "MINS_TO_UNLOCK".to_string(), option_value: KeyValueOptionKind::Single( number("10").with_empty_span() ), }, ] } ); } _ => unreachable!(), } let stmt = verified_stmt("ALTER USER u1 UNSET PASSWORD"); match stmt { Statement::AlterUser(alter) => { assert_eq!(alter.unset_props, vec!["PASSWORD".to_string()]); } _ => unreachable!(), } verified_stmt("ALTER USER u1 UNSET PASSWORD, MUST_CHANGE_PASSWORD, MINS_TO_UNLOCK"); let stmt = verified_stmt("ALTER USER u1 SET DEFAULT_SECONDARY_ROLES=('ALL')"); match stmt { Statement::AlterUser(alter) => { assert_eq!( alter.set_props.options, vec![KeyValueOption { option_name: "DEFAULT_SECONDARY_ROLES".to_string(), option_value: KeyValueOptionKind::Multi(vec![Value::SingleQuotedString( "ALL".to_string() ) .with_empty_span()]) }] ); } _ => unreachable!(), } verified_stmt("ALTER USER u1 SET DEFAULT_SECONDARY_ROLES=()"); verified_stmt("ALTER USER u1 SET DEFAULT_SECONDARY_ROLES=('R1', 'R2', 'R3')"); verified_stmt("ALTER USER u1 SET PASSWORD='secret', DEFAULT_SECONDARY_ROLES=('ALL')"); verified_stmt("ALTER USER u1 SET DEFAULT_SECONDARY_ROLES=('ALL'), PASSWORD='secret'"); let stmt = verified_stmt( "ALTER USER u1 SET WORKLOAD_IDENTITY=(TYPE=AWS, ARN='arn:aws:iam::123456789:r1/')", ); match stmt { Statement::AlterUser(alter) => { assert_eq!( alter.set_props.options, vec![KeyValueOption { option_name: "WORKLOAD_IDENTITY".to_string(), option_value: KeyValueOptionKind::KeyValueOptions(Box::new(KeyValueOptions { delimiter: KeyValueOptionsDelimiter::Comma, options: vec![ KeyValueOption { option_name: "TYPE".to_string(), option_value: KeyValueOptionKind::Single( Value::Placeholder("AWS".to_string()).with_empty_span() ), }, KeyValueOption { option_name: "ARN".to_string(), option_value: KeyValueOptionKind::Single( Value::SingleQuotedString( "arn:aws:iam::123456789:r1/".to_string() ) .with_empty_span() ), }, ] })) }] ) } _ => unreachable!(), } verified_stmt("ALTER USER u1 SET DEFAULT_SECONDARY_ROLES=('ALL'), PASSWORD='secret', WORKLOAD_IDENTITY=(TYPE=AWS, ARN='arn:aws:iam::123456789:r1/')"); verified_stmt("ALTER USER u1 PASSWORD 'AAA'"); verified_stmt("ALTER USER u1 ENCRYPTED PASSWORD 'AAA'"); verified_stmt("ALTER USER u1 PASSWORD NULL"); one_statement_parses_to( "ALTER USER u1 WITH PASSWORD 'AAA'", "ALTER USER u1 PASSWORD 'AAA'", ); } #[test] fn parse_generic_unary_ops() { let unary_ops = &[ ("~", UnaryOperator::BitwiseNot), ("-", UnaryOperator::Minus), ("+", UnaryOperator::Plus), ]; for (str_op, op) in unary_ops { let select = verified_only_select(&format!("SELECT {}expr", &str_op)); assert_eq!( UnnamedExpr(UnaryOp { op: *op, expr: Box::new(Identifier(Ident::new("expr"))), }), select.projection[0] ); } } #[test] fn parse_reset_statement() { match verified_stmt("RESET some_parameter") { Statement::Reset(ResetStatement { reset: Reset::ConfigurationParameter(o), }) => assert_eq!(o, ObjectName::from(vec!["some_parameter".into()])), _ => unreachable!(), } match verified_stmt("RESET some_extension.some_parameter") { Statement::Reset(ResetStatement { reset: Reset::ConfigurationParameter(o), }) => assert_eq!( o, ObjectName::from(vec!["some_extension".into(), "some_parameter".into()]) ), _ => unreachable!(), } match verified_stmt("RESET ALL") { Statement::Reset(ResetStatement { reset }) => assert_eq!(reset, Reset::ALL), _ => unreachable!(), } } #[test] fn test_parse_set_session_authorization() { let stmt = verified_stmt("SET SESSION AUTHORIZATION DEFAULT"); assert_eq!( stmt, Statement::Set(Set::SetSessionAuthorization(SetSessionAuthorizationParam { scope: ContextModifier::Session, kind: SetSessionAuthorizationParamKind::Default, })) ); let stmt = verified_stmt("SET SESSION AUTHORIZATION 'username'"); assert_eq!( stmt, Statement::Set(Set::SetSessionAuthorization(SetSessionAuthorizationParam { scope: ContextModifier::Session, kind: SetSessionAuthorizationParamKind::User(Ident { value: "username".to_string(), quote_style: Some('\''), span: Span::empty(), }), })) ); } #[test] fn test_set_authorization_without_scope_errors() { // This should return a parser error, not panic. let res = parse_sql_statements("SET AUTHORIZATION TIME TIME"); assert!( res.is_err(), "SET AUTHORIZATION without a scope modifier (e.g. SESSION) should error" ); } #[test] fn parse_select_parenthesized_wildcard() { // Test SELECT DISTINCT(*) which uses a parenthesized wildcard // The parentheses are syntactic sugar and get normalized to just * let sql = "SELECT DISTINCT (*) FROM table1"; let canonical = "SELECT DISTINCT * FROM table1"; let select = all_dialects().verified_only_select_with_canonical(sql, canonical); assert_eq!(select.distinct, Some(Distinct::Distinct)); assert_eq!(select.projection.len(), 1); assert!(matches!(select.projection[0], SelectItem::Wildcard(_))); // Also test without spaces: SELECT DISTINCT(*) let sql_no_spaces = "SELECT DISTINCT(*) FROM table1"; let select2 = all_dialects().verified_only_select_with_canonical(sql_no_spaces, canonical); assert_eq!(select2.distinct, Some(Distinct::Distinct)); assert_eq!(select2.projection.len(), 1); assert!(matches!(select2.projection[0], SelectItem::Wildcard(_))); } #[test] fn parse_overlap_as_bool_and() { let dialects = all_dialects_where(|d| d.supports_double_ampersand_operator()); dialects.one_statement_parses_to("SELECT x && y", "SELECT x AND y"); } #[test] fn test_parse_key_value_options_trailing_semicolon() { one_statement_parses_to( "CREATE USER u1 option1='value1' option2='value2';", "CREATE USER u1 option1='value1' option2='value2'", ); } #[test] fn test_binary_kw_as_cast() { all_dialects_where(|d| d.supports_binary_kw_as_cast()) .one_statement_parses_to("SELECT BINARY 1+1", "SELECT CAST(1 + 1 AS BINARY)"); } #[test] fn parse_semi_structured_data_traversal() { let dialects = TestedDialects::new(vec![ Box::new(GenericDialect {}), Box::new(SnowflakeDialect {}), Box::new(DatabricksDialect {}), ]); // most basic case let sql = "SELECT a:b FROM t"; let select = dialects.verified_only_select(sql); assert_eq!( SelectItem::UnnamedExpr(Expr::JsonAccess { value: Box::new(Expr::Identifier(Ident::new("a"))), path: JsonPath { path: vec![JsonPathElem::Dot { key: "b".to_owned(), quoted: false }] }, }), select.projection[0] ); // identifier can be quoted let sql = r#"SELECT a:"my long object key name" FROM t"#; let select = dialects.verified_only_select(sql); assert_eq!( SelectItem::UnnamedExpr(Expr::JsonAccess { value: Box::new(Expr::Identifier(Ident::new("a"))), path: JsonPath { path: vec![JsonPathElem::Dot { key: "my long object key name".to_owned(), quoted: true }] }, }), select.projection[0] ); dialects.verified_stmt("SELECT a:b::INT FROM t"); // unquoted keywords are permitted in the object key let sql = "SELECT a:select, a:from FROM t"; let select = dialects.verified_only_select(sql); assert_eq!( vec![ SelectItem::UnnamedExpr(Expr::JsonAccess { value: Box::new(Expr::Identifier(Ident::new("a"))), path: JsonPath { path: vec![JsonPathElem::Dot { key: "select".to_owned(), quoted: false }] }, }), SelectItem::UnnamedExpr(Expr::JsonAccess { value: Box::new(Expr::Identifier(Ident::new("a"))), path: JsonPath { path: vec![JsonPathElem::Dot { key: "from".to_owned(), quoted: false }] }, }) ], select.projection ); // multiple levels can be traversed // https://docs.snowflake.com/en/user-guide/querying-semistructured#dot-notation let sql = r#"SELECT a:foo."bar".baz"#; let select = dialects.verified_only_select(sql); assert_eq!( vec![SelectItem::UnnamedExpr(Expr::JsonAccess { value: Box::new(Expr::Identifier(Ident::new("a"))), path: JsonPath { path: vec![ JsonPathElem::Dot { key: "foo".to_owned(), quoted: false, }, JsonPathElem::Dot { key: "bar".to_owned(), quoted: true, }, JsonPathElem::Dot { key: "baz".to_owned(), quoted: false, } ] }, })], select.projection ); // dot and bracket notation can be mixed (starting with : case) // https://docs.snowflake.com/en/user-guide/querying-semistructured#dot-notation let sql = r#"SELECT a:foo[0].bar"#; let select = dialects.verified_only_select(sql); assert_eq!( vec![SelectItem::UnnamedExpr(Expr::JsonAccess { value: Box::new(Expr::Identifier(Ident::new("a"))), path: JsonPath { path: vec![ JsonPathElem::Dot { key: "foo".to_owned(), quoted: false, }, JsonPathElem::Bracket { key: Expr::value(number("0")), }, JsonPathElem::Dot { key: "bar".to_owned(), quoted: false, } ] }, })], select.projection ); } #[test] fn parse_array_subscript() { let dialects = all_dialects_except(|d| { d.is::() || d.is::() || d.is::() || d.is::() }); dialects.verified_stmt("SELECT arr[1]"); dialects.verified_stmt("SELECT arr[:]"); dialects.verified_stmt("SELECT arr[1:2]"); dialects.verified_stmt("SELECT arr[1:2:4]"); dialects.verified_stmt("SELECT arr[1:array_length(arr)]"); dialects.verified_stmt("SELECT arr[array_length(arr) - 1:array_length(arr)]"); dialects .verified_stmt("SELECT arr[array_length(arr) - 2:array_length(arr) - 1:array_length(arr)]"); dialects.verified_stmt("SELECT arr[1][2]"); dialects.verified_stmt("SELECT arr[:][:]"); } #[test] fn test_wildcard_func_arg() { // Wildcard (*) and wildcard with EXCLUDE as a function argument. // Documented for Snowflake's HASH function but parsed for any dialect that // supports the wildcard-EXCLUDE select syntax. let dialects = all_dialects_where(|d| d.supports_select_wildcard_exclude()); // Wildcard with EXCLUDE — canonical form has a space before the parenthesised column list. dialects.one_statement_parses_to( "SELECT HASH(* EXCLUDE(col1)) FROM t", "SELECT HASH(* EXCLUDE (col1)) FROM t", ); dialects.verified_expr("HASH(* EXCLUDE (col1))"); dialects.verified_expr("HASH(* EXCLUDE (col1, col2))"); } #[test] fn parse_select_item_multi_column_alias() { all_dialects_where(|d| d.supports_select_item_multi_column_alias()) .verified_stmt("SELECT stack(2, 'a', 'b', 'c', 'd') AS (col1, col2)"); all_dialects_where(|d| d.supports_select_item_multi_column_alias()) .verified_stmt("SELECT stack(2, 'a', 'b', 'c', 'd') AS (col1, col2) FROM t"); assert!( all_dialects_where(|d| !d.supports_select_item_multi_column_alias()) .parse_sql_statements("SELECT stack(2, 'a', 'b') AS (col1, col2)") .is_err() ); } #[test] fn parse_non_pg_dialects_keep_xml_names_as_regular_identifiers() { // On dialects that do NOT support XML expressions, bare `xml` should // be treated as a regular column identifier, not a typed-string prefix. let dialects = all_dialects_except(|d| d.supports_xml_expressions()); dialects.verified_only_select("SELECT xml FROM t"); } apache-datafusion-sqlparser-rs-0.62.0/tests/sqlparser_custom_dialect.rs000066400000000000000000000114131517524037000264160ustar00rootroot00000000000000// 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. //! Test the ability for dialects to override parsing use sqlparser::{ ast::{BinaryOperator, Expr, Statement, Value}, dialect::Dialect, keywords::Keyword, parser::{Parser, ParserError}, tokenizer::Token, }; #[test] fn custom_prefix_parser() -> Result<(), ParserError> { #[derive(Debug)] struct MyDialect {} impl Dialect for MyDialect { fn is_identifier_start(&self, ch: char) -> bool { is_identifier_start(ch) } fn is_identifier_part(&self, ch: char) -> bool { is_identifier_part(ch) } fn parse_prefix(&self, parser: &mut Parser) -> Option> { if parser.consume_token(&Token::Number("1".to_string(), false)) { Some(Ok(Expr::Value(Value::Null.with_empty_span()))) } else { None } } } let dialect = MyDialect {}; let sql = "SELECT 1 + 2"; let ast = Parser::parse_sql(&dialect, sql)?; let query = &ast[0]; assert_eq!("SELECT NULL + 2", &format!("{query}")); Ok(()) } #[test] fn custom_infix_parser() -> Result<(), ParserError> { #[derive(Debug)] struct MyDialect {} impl Dialect for MyDialect { fn is_identifier_start(&self, ch: char) -> bool { is_identifier_start(ch) } fn is_identifier_part(&self, ch: char) -> bool { is_identifier_part(ch) } fn parse_infix( &self, parser: &mut Parser, expr: &Expr, _precedence: u8, ) -> Option> { if parser.consume_token(&Token::Plus) { Some(Ok(Expr::BinaryOp { left: Box::new(expr.clone()), op: BinaryOperator::Multiply, // translate Plus to Multiply right: Box::new(parser.parse_expr().unwrap()), })) } else { None } } } let dialect = MyDialect {}; let sql = "SELECT 1 + 2"; let ast = Parser::parse_sql(&dialect, sql)?; let query = &ast[0]; assert_eq!("SELECT 1 * 2", &format!("{query}")); Ok(()) } #[test] fn custom_statement_parser() -> Result<(), ParserError> { #[derive(Debug)] struct MyDialect {} impl Dialect for MyDialect { fn is_identifier_start(&self, ch: char) -> bool { is_identifier_start(ch) } fn is_identifier_part(&self, ch: char) -> bool { is_identifier_part(ch) } fn parse_statement(&self, parser: &mut Parser) -> Option> { if parser.parse_keyword(Keyword::SELECT) { for _ in 0..3 { let _ = parser.next_token(); } Some(Ok(Statement::Commit { chain: false, end: false, modifier: None, })) } else { None } } } let dialect = MyDialect {}; let sql = "SELECT 1 + 2"; let ast = Parser::parse_sql(&dialect, sql)?; let query = &ast[0]; assert_eq!("COMMIT", &format!("{query}")); Ok(()) } #[test] fn test_map_syntax_not_support_default() -> Result<(), ParserError> { #[derive(Debug)] struct MyDialect {} impl Dialect for MyDialect { fn is_identifier_start(&self, ch: char) -> bool { is_identifier_start(ch) } fn is_identifier_part(&self, ch: char) -> bool { is_identifier_part(ch) } } let dialect = MyDialect {}; let sql = "SELECT MAP {1: 2}"; let ast = Parser::parse_sql(&dialect, sql); assert!(ast.is_err()); Ok(()) } fn is_identifier_start(ch: char) -> bool { ch.is_ascii_lowercase() || ch.is_ascii_uppercase() || ch == '_' } fn is_identifier_part(ch: char) -> bool { ch.is_ascii_lowercase() || ch.is_ascii_uppercase() || ch.is_ascii_digit() || ch == '$' || ch == '_' } apache-datafusion-sqlparser-rs-0.62.0/tests/sqlparser_databricks.rs000066400000000000000000000647661517524037000255510ustar00rootroot00000000000000// 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::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] mod test_utils; fn databricks() -> TestedDialects { TestedDialects::new(vec![Box::new(DatabricksDialect {})]) } fn databricks_and_generic() -> TestedDialects { TestedDialects::new(vec![ Box::new(DatabricksDialect {}), Box::new(GenericDialect {}), ]) } #[test] fn test_databricks_identifiers() { // databricks uses backtick for delimited identifiers assert_eq!( databricks().verified_only_select("SELECT `Ä`").projection[0], SelectItem::UnnamedExpr(Expr::Identifier(Ident::with_quote('`', "Ä"))) ); // double quotes produce string literals, not delimited identifiers assert_eq!( databricks() .verified_only_select(r#"SELECT "Ä""#) .projection[0], SelectItem::UnnamedExpr(Expr::Value( (Value::DoubleQuotedString("Ä".to_owned())).with_empty_span() )) ); } #[test] fn test_databricks_exists() { // exists is a function in databricks assert_eq!( databricks().verified_expr("exists(array(1, 2, 3), x -> x IS NULL)"), call( "exists", [ call( "array", [ Expr::value(number("1")), Expr::value(number("2")), Expr::value(number("3")) ] ), Expr::Lambda(LambdaFunction { params: OneOrManyWithParens::One(LambdaFunctionParameter { name: Ident::new("x"), data_type: None }), body: Box::new(Expr::IsNull(Box::new(Expr::Identifier(Ident::new("x"))))), syntax: LambdaSyntax::Arrow, }) ] ), ); let res = databricks().parse_sql_statements("SELECT EXISTS ("); assert_eq!( // TODO: improve this error message... ParserError::ParserError("Expected: an expression, found: EOF".to_string()), res.unwrap_err(), ); } #[test] fn test_databricks_lambdas() { #[rustfmt::skip] let sql = concat!( "SELECT array_sort(array('Hello', 'World'), ", "(p1, p2) -> CASE WHEN p1 = p2 THEN 0 ", "WHEN reverse(p1) < reverse(p2) THEN -1 ", "ELSE 1 END)", ); pretty_assertions::assert_eq!( SelectItem::UnnamedExpr(call( "array_sort", [ call( "array", [ Expr::value(Value::SingleQuotedString("Hello".to_owned())), Expr::value(Value::SingleQuotedString("World".to_owned())) ] ), Expr::Lambda(LambdaFunction { params: OneOrManyWithParens::Many(vec![ LambdaFunctionParameter { name: Ident::new("p1"), data_type: None }, LambdaFunctionParameter { name: Ident::new("p2"), data_type: None } ]), 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"))) } }, ], else_result: Some(Box::new(Expr::value(number("1")))) }), syntax: LambdaSyntax::Arrow, }) ] )), databricks().verified_only_select(sql).projection[0] ); databricks().verified_expr( "map_zip_with(map(1, 'a', 2, 'b'), map(1, 'x', 2, 'y'), (k, v1, v2) -> concat(v1, v2))", ); databricks().verified_expr("transform(array(1, 2, 3), x -> x + 1)"); } #[test] fn test_values_clause() { let values = Values { value_keyword: false, explicit_row: false, rows: vec![ Parens::with_empty_span(vec![ Expr::Value((Value::DoubleQuotedString("one".to_owned())).with_empty_span()), Expr::value(number("1")), ]), Parens::with_empty_span(vec![ Expr::Value((Value::SingleQuotedString("two".to_owned())).with_empty_span()), Expr::value(number("2")), ]), ], }; let query = databricks().verified_query(r#"VALUES ("one", 1), ('two', 2)"#); assert_eq!(SetExpr::Values(values.clone()), *query.body); // VALUES is permitted in a FROM clause without a subquery let query = databricks().verified_query_with_canonical( r#"SELECT * FROM VALUES ("one", 1), ('two', 2)"#, r#"SELECT * FROM (VALUES ("one", 1), ('two', 2))"#, ); let Some(TableFactor::Derived { subquery, .. }) = query .body .as_select() .map(|select| &select.from[0].relation) else { panic!("expected subquery"); }; assert_eq!(SetExpr::Values(values), *subquery.body); // values is also a valid table name let query = databricks_and_generic().verified_query(concat!( "WITH values AS (SELECT 42) ", "SELECT * FROM values", )); assert_eq!( Some(&table_from_name(ObjectName::from(vec![Ident::new( "values" )]))), query .body .as_select() .map(|select| &select.from[0].relation) ); // TODO: support this example from https://docs.databricks.com/en/sql/language-manual/sql-ref-syntax-qry-select-values.html#examples // databricks().verified_query("VALUES 1, 2, 3"); } #[test] fn parse_use() { let valid_object_names = ["mydb", "WAREHOUSE", "DEFAULT"]; let quote_styles = ['"', '`']; 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( 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( quote, object_name.to_string(), )]))) ); } } 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( 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( 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( quote, "my_schema".to_string(), )]))) ); } // 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" )]))) ); assert_eq!( databricks().verified_stmt("USE DATABASE my_schema"), Statement::Use(Use::Database(ObjectName::from(vec![Ident::new( "my_schema" )]))) ); assert_eq!( databricks().verified_stmt("USE SCHEMA my_schema"), Statement::Use(Use::Schema(ObjectName::from(vec![Ident::new("my_schema")]))) ); // Test invalid syntax - missing identifier let invalid_cases = ["USE SCHEMA", "USE DATABASE", "USE CATALOG"]; for sql in &invalid_cases { assert_eq!( databricks().parse_sql_statements(sql).unwrap_err(), ParserError::ParserError("Expected: identifier, found: EOF".to_string()), ); } } #[test] fn parse_show_catalogs() { databricks().verified_stmt("SHOW CATALOGS"); databricks().verified_stmt("SHOW TERSE CATALOGS"); databricks().verified_stmt("SHOW CATALOGS HISTORY"); databricks().verified_stmt("SHOW CATALOGS LIKE 'pay*'"); databricks().verified_stmt("SHOW CATALOGS 'pay*'"); databricks().verified_stmt("SHOW CATALOGS STARTS WITH 'pay'"); databricks().verified_stmt("SHOW CATALOGS LIMIT 10"); databricks().verified_stmt("SHOW CATALOGS HISTORY STARTS WITH 'pay'"); match databricks().verified_stmt("SHOW CATALOGS LIKE 'pay*'") { Statement::ShowCatalogs { terse, history, show_options, } => { assert!(!terse); assert!(!history); assert_eq!(show_options.show_in, None); assert_eq!(show_options.starts_with, None); assert_eq!(show_options.limit, None); assert_eq!(show_options.limit_from, None); assert_eq!( show_options.filter_position, Some(ShowStatementFilterPosition::Suffix( ShowStatementFilter::Like("pay*".to_string()) )) ); } _ => unreachable!(), } } #[test] fn parse_show_catalogs_with_show_options() { databricks().verified_stmt("SHOW TERSE CATALOGS HISTORY IN ACCOUNT"); match databricks().verified_stmt("SHOW TERSE CATALOGS HISTORY IN ACCOUNT") { Statement::ShowCatalogs { terse, history, show_options, } => { assert!(terse); assert!(history); assert_eq!(show_options.filter_position, None); assert!(matches!( show_options.show_in, Some(ShowStatementIn { parent_type: Some(ShowStatementInParentType::Account), parent_name: None, .. }) )); } _ => unreachable!(), } } #[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(TypedString { data_type: DataType::TimestampNtz(None), value: ValueWithSpan { value: Value::SingleQuotedString("2025-03-29T18:52:00".to_owned()), span: Span::empty(), }, uses_odbc_syntax: false }) ); // 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(None), array: false, 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(None), options: vec![], }] ); } s => panic!("Unexpected statement: {s:?}"), } } #[test] fn parse_table_time_travel() { all_dialects_where(|d| d.supports_table_versioning()) .verified_only_select("SELECT 1 FROM t1 TIMESTAMP AS OF '2018-10-18T22:15:12.013Z'"); all_dialects_where(|d| d.supports_table_versioning()).verified_only_select( "SELECT 1 FROM t1 TIMESTAMP AS OF CURRENT_TIMESTAMP() - INTERVAL 12 HOURS", ); all_dialects_where(|d| d.supports_table_versioning()) .verified_only_select("SELECT 1 FROM t1 VERSION AS OF 1"); assert!(databricks() .parse_sql_statements("SELECT 1 FROM t1 FOR TIMESTAMP AS OF 'some_timestamp'") .is_err()); assert!(all_dialects_where(|d| d.supports_table_versioning()) .parse_sql_statements("SELECT 1 FROM t1 VERSION AS OF 1 - 2",) .is_err()) } #[test] fn parse_optimize_table() { // Basic OPTIMIZE (Databricks style - no TABLE keyword) databricks().verified_stmt("OPTIMIZE my_table"); databricks().verified_stmt("OPTIMIZE db.my_table"); databricks().verified_stmt("OPTIMIZE catalog.db.my_table"); // With WHERE clause databricks().verified_stmt("OPTIMIZE my_table WHERE date = '2023-01-01'"); databricks() .verified_stmt("OPTIMIZE my_table WHERE date >= '2023-01-01' AND date < '2023-02-01'"); // With ZORDER BY clause databricks().verified_stmt("OPTIMIZE my_table ZORDER BY (col1)"); databricks().verified_stmt("OPTIMIZE my_table ZORDER BY (col1, col2)"); databricks().verified_stmt("OPTIMIZE my_table ZORDER BY (col1, col2, col3)"); // Combined WHERE and ZORDER BY databricks().verified_stmt("OPTIMIZE my_table WHERE date = '2023-01-01' ZORDER BY (col1)"); databricks() .verified_stmt("OPTIMIZE my_table WHERE date >= '2023-01-01' ZORDER BY (col1, col2)"); // Verify AST structure match databricks() .verified_stmt("OPTIMIZE my_table WHERE date = '2023-01-01' ZORDER BY (col1, col2)") { Statement::OptimizeTable { name, has_table_keyword, on_cluster, partition, include_final, deduplicate, predicate, zorder, } => { assert_eq!(name.to_string(), "my_table"); assert!(!has_table_keyword); assert!(on_cluster.is_none()); assert!(partition.is_none()); assert!(!include_final); assert!(deduplicate.is_none()); assert!(predicate.is_some()); assert_eq!( zorder, Some(vec![ Expr::Identifier(Ident::new("col1")), Expr::Identifier(Ident::new("col2")), ]) ); } _ => unreachable!(), } // Negative cases assert_eq!( databricks() .parse_sql_statements("OPTIMIZE my_table ZORDER BY") .unwrap_err(), ParserError::ParserError("Expected: (, found: EOF".to_string()) ); assert_eq!( databricks() .parse_sql_statements("OPTIMIZE my_table ZORDER BY ()") .unwrap_err(), ParserError::ParserError("Expected: an expression, found: )".to_string()) ); } #[test] fn parse_create_table_partitioned_by() { // Databricks allows PARTITIONED BY with just column names (referencing existing columns) // https://docs.databricks.com/en/sql/language-manual/sql-ref-partition.html // Single partition column without type databricks().verified_stmt("CREATE TABLE t (col1 STRING, col2 INT) PARTITIONED BY (col1)"); // Multiple partition columns without types databricks().verified_stmt( "CREATE TABLE t (col1 STRING, col2 INT, col3 DATE) PARTITIONED BY (col1, col2)", ); // Partition columns with types (new columns not in table spec) databricks().verified_stmt("CREATE TABLE t (name STRING) PARTITIONED BY (year INT, month INT)"); // Mixed: some with types, some without databricks() .verified_stmt("CREATE TABLE t (id INT, name STRING) PARTITIONED BY (region, year INT)"); // Verify AST structure for column without type match databricks().verified_stmt("CREATE TABLE t (col1 STRING) PARTITIONED BY (col1)") { Statement::CreateTable(CreateTable { name, columns, hive_distribution, .. }) => { assert_eq!(name.to_string(), "t"); assert_eq!(columns.len(), 1); assert_eq!(columns[0].name.to_string(), "col1"); match hive_distribution { HiveDistributionStyle::PARTITIONED { columns: partition_cols, } => { assert_eq!(partition_cols.len(), 1); assert_eq!(partition_cols[0].name.to_string(), "col1"); assert_eq!(partition_cols[0].data_type, DataType::Unspecified); } _ => unreachable!(), } } _ => unreachable!(), } // Verify AST structure for column with type match databricks().verified_stmt("CREATE TABLE t (name STRING) PARTITIONED BY (year INT)") { Statement::CreateTable(CreateTable { hive_distribution: HiveDistributionStyle::PARTITIONED { columns: partition_cols, }, .. }) => { assert_eq!(partition_cols.len(), 1); assert_eq!(partition_cols[0].name.to_string(), "year"); assert_eq!(partition_cols[0].data_type, DataType::Int(None)); } _ => unreachable!(), } } #[test] fn parse_databricks_struct_type() { // Databricks uses colon-separated struct field syntax (colon is optional) // https://docs.databricks.com/en/sql/language-manual/data-types/struct-type.html // Basic struct with colon syntax - parses to canonical form without colons databricks().one_statement_parses_to( "CREATE TABLE t (col1 STRUCT)", "CREATE TABLE t (col1 STRUCT)", ); // Nested array of struct (the original issue case) databricks().one_statement_parses_to( "CREATE TABLE t (col1 ARRAY>)", "CREATE TABLE t (col1 ARRAY>)", ); // Multiple struct columns databricks().one_statement_parses_to( "CREATE TABLE t (col1 STRUCT, col2 STRUCT)", "CREATE TABLE t (col1 STRUCT, col2 STRUCT)", ); // Deeply nested structs databricks().one_statement_parses_to( "CREATE TABLE t (col1 STRUCT>)", "CREATE TABLE t (col1 STRUCT>)", ); // Struct with array field databricks().one_statement_parses_to( "CREATE TABLE t (col1 STRUCT, name: STRING>)", "CREATE TABLE t (col1 STRUCT, name STRING>)", ); // Syntax without colons should also work (BigQuery compatible) databricks().verified_stmt("CREATE TABLE t (col1 STRUCT)"); // Verify AST structure match databricks().one_statement_parses_to( "CREATE TABLE t (col1 STRUCT)", "CREATE TABLE t (col1 STRUCT)", ) { Statement::CreateTable(CreateTable { columns, .. }) => { assert_eq!(columns.len(), 1); assert_eq!(columns[0].name.to_string(), "col1"); match &columns[0].data_type { DataType::Struct(fields, StructBracketKind::AngleBrackets) => { assert_eq!(fields.len(), 2); assert_eq!( fields[0].field_name.as_ref().map(|i| i.to_string()), Some("field1".to_string()) ); assert_eq!(fields[0].field_type, DataType::String(None)); assert_eq!( fields[1].field_name.as_ref().map(|i| i.to_string()), Some("field2".to_string()) ); assert_eq!(fields[1].field_type, DataType::Int(None)); } _ => unreachable!(), } } _ => unreachable!(), } } #[test] fn parse_databricks_json_accessor() { // Basic colon accessor — unquoted field names are case-insensitive databricks().verified_only_select("SELECT raw:owner, RAW:owner FROM store_data"); // Unquoted field access is case-insensitive; bracket notation is case-sensitive. databricks().verified_only_select( "SELECT raw:OWNER AS case_insensitive, raw:['OWNER'] AS case_sensitive FROM store_data", ); // Backtick-quoted keys (Databricks delimited identifiers) normalise to double-quoted output. databricks().one_statement_parses_to( "SELECT raw:`zip code`, raw:`Zip Code`, raw:['fb:testid'] FROM store_data", r#"SELECT raw:"zip code", raw:"Zip Code", raw:['fb:testid'] FROM store_data"#, ); // Dot notation databricks().verified_only_select("SELECT raw:store.bicycle FROM store_data"); // String-key bracket notation after a dot segment databricks() .verified_only_select("SELECT raw:store['bicycle'], raw:store['BICYCLE'] FROM store_data"); // Integer-index bracket notation databricks() .verified_only_select("SELECT raw:store.fruit[0], raw:store.fruit[1] FROM store_data"); // Wildcard [*] — including chained and mixed positions databricks().verified_only_select( "SELECT raw:store.basket[*], raw:store.basket[*][0] AS first_of_baskets, \ raw:store.basket[0][*] AS first_basket, raw:store.basket[*][*] AS all_elements_flattened, \ raw:store.basket[0][2].b AS subfield FROM store_data", ); // Dot access following a wildcard bracket databricks().verified_only_select("SELECT raw:store.book[*].isbn FROM store_data"); // Double-colon cast — type keyword normalises to upper case databricks().one_statement_parses_to( "SELECT raw:store.bicycle.price::double FROM store_data", "SELECT raw:store.bicycle.price::DOUBLE FROM store_data", ); } #[test] fn parse_numeric_prefix_identifier() { databricks().verified_stmt("SELECT * FROM catalog.schema.1st_table"); databricks().verified_stmt("SELECT * FROM a.b.1c"); } #[test] fn parse_cte_without_as() { databricks_and_generic().one_statement_parses_to( "WITH cte (SELECT 1) SELECT * FROM cte", "WITH cte AS (SELECT 1) SELECT * FROM cte", ); databricks_and_generic().one_statement_parses_to( "WITH a AS (SELECT 1), b (SELECT 2) SELECT * FROM a, b", "WITH a AS (SELECT 1), b AS (SELECT 2) SELECT * FROM a, b", ); databricks_and_generic().one_statement_parses_to( "WITH cte (col1, col2) (SELECT 1, 2) SELECT * FROM cte", "WITH cte (col1, col2) AS (SELECT 1, 2) SELECT * FROM cte", ); databricks_and_generic().verified_query("WITH cte AS (SELECT 1) SELECT * FROM cte"); databricks_and_generic() .verified_query("WITH cte (col1, col2) AS (SELECT 1, 2) SELECT * FROM cte"); assert!(all_dialects_where(|d| !d.supports_cte_without_as()) .parse_sql_statements("WITH cte (SELECT 1) SELECT * FROM cte") .is_err()); } apache-datafusion-sqlparser-rs-0.62.0/tests/sqlparser_derive_dialect.rs000066400000000000000000000075601517524037000263720ustar00rootroot00000000000000// 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. //! Tests for the `derive_dialect!` macro. use sqlparser::derive_dialect; use sqlparser::dialect::{Dialect, GenericDialect, MySqlDialect, PostgreSqlDialect}; use sqlparser::parser::Parser; #[test] fn test_method_overrides() { derive_dialect!(EnhancedGenericDialect, GenericDialect, overrides = { supports_order_by_all = true, supports_triple_quoted_string = true, }); let dialect = EnhancedGenericDialect::new(); // Overridden methods assert!(dialect.supports_order_by_all()); assert!(dialect.supports_triple_quoted_string()); // Non-overridden retains base behavior assert!(!dialect.supports_factorial_operator()); // Parsing works with the overrides let result = Parser::new(&dialect) .try_with_sql("SELECT '''value''' FROM t ORDER BY ALL") .unwrap() .parse_statements(); assert!(result.is_ok()); } #[test] fn test_preserve_type_id() { // Check the override works and the parser recognizes it as the base type derive_dialect!( PreservedTypeDialect, GenericDialect, preserve_type_id = true, overrides = { supports_order_by_all = true } ); let dialect = PreservedTypeDialect::new(); let d: &dyn Dialect = &dialect; assert!(dialect.supports_order_by_all()); assert!(d.is::()); } #[test] fn test_different_base_dialects() { derive_dialect!( EnhancedMySqlDialect, MySqlDialect, overrides = { supports_order_by_all = true } ); derive_dialect!(UniquePostgreSqlDialect, PostgreSqlDialect); let pg = UniquePostgreSqlDialect::new(); let mysql = EnhancedMySqlDialect::new(); // Inherit different base behaviors assert!(pg.supports_filter_during_aggregation()); // PostgreSQL feature assert!(mysql.supports_string_literal_backslash_escape()); // MySQL feature assert!(mysql.supports_order_by_all()); // Override // Each has unique TypeId let pg_ref: &dyn Dialect = &pg; let mysql_ref: &dyn Dialect = &mysql; assert!(pg_ref.is::()); assert!(!pg_ref.is::()); assert!(mysql_ref.is::()); } #[test] fn test_identifier_quote_style_overrides() { derive_dialect!( BacktickGenericDialect, GenericDialect, overrides = { identifier_quote_style = '`' } ); derive_dialect!( AnotherBacktickDialect, GenericDialect, overrides = { identifier_quote_style = '[' } ); derive_dialect!( QuotelessPostgreSqlDialect, PostgreSqlDialect, preserve_type_id = true, overrides = { identifier_quote_style = None } ); // Char literal (auto-wrapped in Some) assert_eq!( BacktickGenericDialect::new().identifier_quote_style("x"), Some('`') ); // Another char literal assert_eq!( AnotherBacktickDialect::new().identifier_quote_style("x"), Some('[') ); // None (overrides PostgreSQL's default '"') assert_eq!( QuotelessPostgreSqlDialect::new().identifier_quote_style("x"), None ); } apache-datafusion-sqlparser-rs-0.62.0/tests/sqlparser_duckdb.rs000066400000000000000000000751431517524037000246650ustar00rootroot00000000000000// 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. #[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 {})]) } fn duckdb_and_generic() -> TestedDialects { TestedDialects::new(vec![ Box::new(DuckDbDialect {}), Box::new(GenericDialect {}), ]) } #[test] fn test_struct() { // s STRUCT(v VARCHAR, i INTEGER) let struct_type1 = DataType::Struct( vec![ 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, ); // basic struct let statement = duckdb().verified_stmt(r#"CREATE TABLE t1 (s STRUCT(v VARCHAR, i INTEGER))"#); assert_eq!( column_defs(statement), vec![ColumnDef { name: "s".into(), data_type: struct_type1.clone(), options: vec![], }] ); // struct array let statement = duckdb().verified_stmt(r#"CREATE TABLE t1 (s STRUCT(v VARCHAR, i INTEGER)[])"#); assert_eq!( column_defs(statement), vec![ColumnDef { name: "s".into(), data_type: DataType::Array(ArrayElemTypeDef::SquareBracket( Box::new(struct_type1), None )), options: vec![], }] ); // s STRUCT(v VARCHAR, s STRUCT(a1 INTEGER, a2 VARCHAR)) let struct_type2 = DataType::Struct( vec![ StructField { field_name: Some(Ident::new("v")), field_type: DataType::Varchar(None), options: None, }, StructField { field_name: Some(Ident::new("s")), field_type: DataType::Struct( vec![ 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, ); // nested struct let statement = duckdb().verified_stmt( r#"CREATE TABLE t1 (s STRUCT(v VARCHAR, s STRUCT(a1 INTEGER, a2 VARCHAR))[])"#, ); assert_eq!( column_defs(statement), vec![ColumnDef { name: "s".into(), data_type: DataType::Array(ArrayElemTypeDef::SquareBracket( Box::new(struct_type2), None )), options: vec![], }] ); // failing test (duckdb does not support bracket syntax) let sql_list = vec![ r#"CREATE TABLE t1 (s STRUCT(v VARCHAR, i INTEGER)))"#, r#"CREATE TABLE t1 (s STRUCT(v VARCHAR, i INTEGER>)"#, r#"CREATE TABLE t1 (s STRUCT)"#, r#"CREATE TABLE t1 (s STRUCT v VARCHAR, i INTEGER )"#, r#"CREATE TABLE t1 (s STRUCT VARCHAR, i INTEGER )"#, r#"CREATE TABLE t1 (s STRUCT (VARCHAR, INTEGER))"#, ]; for sql in sql_list { duckdb().parse_sql_statements(sql).unwrap_err(); } } /// Returns the ColumnDefinitions from a CreateTable statement fn column_defs(statement: Statement) -> Vec { match statement { Statement::CreateTable(CreateTable { columns, .. }) => columns, _ => panic!("Expected CreateTable"), } } #[test] fn test_select_wildcard_with_exclude() { let select = duckdb().verified_only_select("SELECT * EXCLUDE (col_a) FROM data"); let expected = SelectItem::Wildcard(WildcardAdditionalOptions { opt_exclude: Some(ExcludeSelectItem::Multiple(vec![ObjectName::from( Ident::new("col_a"), )])), ..Default::default() }); assert_eq!(expected, select.projection[0]); 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")])), WildcardAdditionalOptions { opt_exclude: Some(ExcludeSelectItem::Single(ObjectName::from(Ident::new( "department_id", )))), ..Default::default() }, ); assert_eq!(expected, select.projection[0]); let select = duckdb() .verified_only_select("SELECT * EXCLUDE (department_id, employee_id) FROM employee_table"); let expected = SelectItem::Wildcard(WildcardAdditionalOptions { opt_exclude: Some(ExcludeSelectItem::Multiple(vec![ ObjectName::from(Ident::new("department_id")), ObjectName::from(Ident::new("employee_id")), ])), ..Default::default() }); assert_eq!(expected, select.projection[0]); } #[test] fn parse_div_infix() { duckdb_and_generic().verified_stmt(r#"SELECT 5 // 2"#); } #[test] fn test_create_macro() { let macro_ = duckdb().verified_stmt("CREATE MACRO schema.add(a, b) AS a + b"); let expected = Statement::CreateMacro { or_replace: false, temporary: false, name: ObjectName::from(vec![Ident::new("schema"), Ident::new("add")]), args: Some(vec![MacroArg::new("a"), MacroArg::new("b")]), definition: MacroDefinition::Expr(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("a"))), op: BinaryOperator::Plus, right: Box::new(Expr::Identifier(Ident::new("b"))), }), }; assert_eq!(expected, macro_); } #[test] fn test_create_macro_default_args() { let macro_ = duckdb().verified_stmt("CREATE MACRO add_default(a, b := 5) AS a + b"); let expected = Statement::CreateMacro { or_replace: false, temporary: false, name: ObjectName::from(vec![Ident::new("add_default")]), args: Some(vec![ MacroArg::new("a"), MacroArg { name: Ident::new("b"), default_expr: Some(Expr::value(number("5"))), }, ]), definition: MacroDefinition::Expr(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("a"))), op: BinaryOperator::Plus, right: Box::new(Expr::Identifier(Ident::new("b"))), }), }; assert_eq!(expected, macro_); } #[test] fn test_create_table_macro() { let query = "SELECT col1_value AS column1, col2_value AS column2 UNION ALL SELECT 'Hello' AS col1_value, 456 AS col2_value"; let macro_ = duckdb().verified_stmt( &("CREATE OR REPLACE TEMPORARY MACRO dynamic_table(col1_value, col2_value) AS TABLE " .to_string() + query), ); let expected = Statement::CreateMacro { or_replace: true, temporary: true, name: ObjectName::from(vec![Ident::new("dynamic_table")]), args: Some(vec![ MacroArg::new("col1_value"), MacroArg::new("col2_value"), ]), definition: MacroDefinition::Table(duckdb().verified_query(query).into()), }; assert_eq!(expected, macro_); } #[test] fn test_select_union_by_name() { let q1 = "SELECT * FROM capitals UNION BY NAME SELECT * FROM weather"; let q2 = "SELECT * FROM capitals UNION ALL BY NAME SELECT * FROM weather"; let q3 = "SELECT * FROM capitals UNION DISTINCT BY NAME SELECT * FROM weather"; for (ast, expected_quantifier) in &[ (duckdb().verified_query(q1), SetQuantifier::ByName), (duckdb().verified_query(q2), SetQuantifier::AllByName), (duckdb().verified_query(q3), SetQuantifier::DistinctByName), ] { let expected = Box::::new(SetExpr::SetOperation { op: SetOperator::Union, set_quantifier: *expected_quantifier, left: Box::::new(SetExpr::Select(Box::new(Select { select_token: AttachedToken::empty(), optimizer_hints: vec![], distinct: None, select_modifiers: None, top: None, projection: vec![SelectItem::Wildcard(WildcardAdditionalOptions::default())], exclude: None, top_before_distinct: false, into: None, from: vec![TableWithJoins { relation: table_from_name(ObjectName::from(vec![Ident { value: "capitals".to_string(), quote_style: None, span: Span::empty(), }])), joins: vec![], }], lateral_views: vec![], prewhere: None, selection: None, group_by: GroupByExpr::Expressions(vec![], vec![]), cluster_by: vec![], distribute_by: vec![], sort_by: vec![], having: None, named_window: vec![], window_before_qualify: false, qualify: None, value_table_mode: None, connect_by: vec![], flavor: SelectFlavor::Standard, }))), right: Box::::new(SetExpr::Select(Box::new(Select { select_token: AttachedToken::empty(), optimizer_hints: vec![], distinct: None, select_modifiers: None, top: None, projection: vec![SelectItem::Wildcard(WildcardAdditionalOptions::default())], exclude: None, top_before_distinct: false, into: None, from: vec![TableWithJoins { relation: table_from_name(ObjectName::from(vec![Ident { value: "weather".to_string(), quote_style: None, span: Span::empty(), }])), joins: vec![], }], lateral_views: vec![], prewhere: None, selection: None, group_by: GroupByExpr::Expressions(vec![], vec![]), cluster_by: vec![], distribute_by: vec![], sort_by: vec![], having: None, named_window: vec![], window_before_qualify: false, qualify: None, value_table_mode: None, connect_by: vec![], flavor: SelectFlavor::Standard, }))), }); assert_eq!(ast.body, expected); } } #[test] fn test_duckdb_install() { let stmt = duckdb().verified_stmt("INSTALL tpch"); assert_eq!( stmt, Statement::Install { extension_name: Ident { value: "tpch".to_string(), quote_style: None, span: Span::empty() } } ); } #[test] fn test_duckdb_load_extension() { let stmt = duckdb().verified_stmt("LOAD my_extension"); assert_eq!( Statement::Load { extension_name: Ident { value: "my_extension".to_string(), quote_style: None, span: Span::empty() } }, 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(), array: false, 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 //syntax: {'field_name': expr1[, ... ]} let sql = "SELECT {'a': 1, 'b': 2, 'c': 3}, [{'a': 'abc'}], {'a': 1, 'b': [t.str_col]}, {'a': 1, 'b': 'abc'}, {'abc': str_col}, {'a': {'aa': 1}}"; let select = duckdb_and_generic().verified_only_select(sql); assert_eq!(6, select.projection.len()); assert_eq!( &Expr::Dictionary(vec![ DictionaryField { key: Ident::with_quote('\'', "a"), value: Box::new(Expr::value(number("1"))), }, DictionaryField { key: Ident::with_quote('\'', "b"), value: Box::new(Expr::value(number("2"))), }, DictionaryField { key: Ident::with_quote('\'', "c"), value: Box::new(Expr::value(number("3"))), }, ],), expr_from_projection(&select.projection[0]) ); assert_eq!( &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() )), },],)], named: false }), expr_from_projection(&select.projection[1]) ); assert_eq!( &Expr::Dictionary(vec![ DictionaryField { key: Ident::with_quote('\'', "a"), value: Box::new(Expr::value(number("1"))), }, DictionaryField { key: Ident::with_quote('\'', "b"), value: Box::new(Expr::Array(Array { elem: vec![Expr::CompoundIdentifier(vec![ Ident::from("t"), Ident::from("str_col") ])], named: false })), }, ],), expr_from_projection(&select.projection[2]) ); assert_eq!( &Expr::Dictionary(vec![ DictionaryField { key: Ident::with_quote('\'', "a"), value: Expr::value(number("1")).into(), }, DictionaryField { key: Ident::with_quote('\'', "b"), value: Expr::Value( (Value::SingleQuotedString("abc".to_string())).with_empty_span() ) .into(), }, ],), expr_from_projection(&select.projection[3]) ); assert_eq!( &Expr::Dictionary(vec![DictionaryField { key: Ident::with_quote('\'', "abc"), value: Expr::Identifier(Ident::from("str_col")).into(), }],), expr_from_projection(&select.projection[4]) ); assert_eq!( &Expr::Dictionary(vec![DictionaryField { key: Ident::with_quote('\'', "a"), value: Expr::Dictionary(vec![DictionaryField { key: Ident::with_quote('\'', "aa"), value: Expr::value(number("1")).into(), }],) .into(), }],), expr_from_projection(&select.projection[5]) ); } #[test] fn test_create_secret() { let sql = r#"CREATE OR REPLACE PERSISTENT SECRET IF NOT EXISTS name IN storage ( TYPE type, key1 value1, key2 value2 )"#; let stmt = duckdb().verified_stmt(sql); assert_eq!( Statement::CreateSecret { or_replace: true, temporary: Some(false), if_not_exists: true, name: Some(Ident::new("name")), storage_specifier: Some(Ident::new("storage")), secret_type: Ident::new("type"), options: vec![ SecretOption { key: Ident::new("key1"), value: Ident::new("value1"), }, SecretOption { key: Ident::new("key2"), value: Ident::new("value2"), } ] }, stmt ); } #[test] fn test_create_secret_simple() { let sql = r#"CREATE SECRET ( TYPE type )"#; let stmt = duckdb().verified_stmt(sql); assert_eq!( Statement::CreateSecret { or_replace: false, temporary: None, if_not_exists: false, name: None, storage_specifier: None, secret_type: Ident::new("type"), options: vec![] }, stmt ); } #[test] fn test_drop_secret() { let sql = r#"DROP PERSISTENT SECRET IF EXISTS secret FROM storage"#; let stmt = duckdb().verified_stmt(sql); assert_eq!( Statement::DropSecret { if_exists: true, temporary: Some(false), name: Ident::new("secret"), storage_specifier: Some(Ident::new("storage")) }, stmt ); } #[test] fn test_drop_secret_simple() { let sql = r#"DROP SECRET secret"#; let stmt = duckdb().verified_stmt(sql); assert_eq!( Statement::DropSecret { if_exists: false, temporary: None, name: Ident::new("secret"), storage_specifier: None }, stmt ); } #[test] fn test_attach_database() { let sql = r#"ATTACH DATABASE IF NOT EXISTS 'sqlite_file.db' AS sqlite_db (READ_ONLY false, TYPE SQLITE)"#; let stmt = duckdb().verified_stmt(sql); assert_eq!( Statement::AttachDuckDBDatabase { if_not_exists: true, database: true, database_path: Ident::with_quote('\'', "sqlite_file.db"), database_alias: Some(Ident::new("sqlite_db")), attach_options: vec![ AttachDuckDBDatabaseOption::ReadOnly(Some(false)), AttachDuckDBDatabaseOption::Type(Ident::new("SQLITE")), ] }, stmt ); } #[test] fn test_attach_database_simple() { let sql = r#"ATTACH 'postgres://user.name:pass-word@some.url.com:5432/postgres'"#; let stmt = duckdb().verified_stmt(sql); assert_eq!( Statement::AttachDuckDBDatabase { if_not_exists: false, database: false, database_path: Ident::with_quote( '\'', "postgres://user.name:pass-word@some.url.com:5432/postgres" ), database_alias: None, attach_options: vec![] }, stmt ); } #[test] fn test_detach_database() { let sql = r#"DETACH DATABASE IF EXISTS db_name"#; let stmt = duckdb().verified_stmt(sql); assert_eq!( Statement::DetachDuckDBDatabase { if_exists: true, database: true, database_alias: Ident::new("db_name"), }, stmt ); } #[test] fn test_detach_database_simple() { let sql = r#"DETACH db_name"#; let stmt = duckdb().verified_stmt(sql); assert_eq!( Statement::DetachDuckDBDatabase { if_exists: false, database: false, database_alias: Ident::new("db_name"), }, stmt ); } #[test] fn test_duckdb_named_argument_function_with_assignment_operator() { let sql = "SELECT FUN(a := '1', b := '2') FROM foo"; 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, 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() )), operator: FunctionArgOperator::Assignment }, FunctionArg::Named { name: Ident::new("b"), arg: FunctionArgExpr::Expr(Expr::Value( (Value::SingleQuotedString("2".to_owned())).with_empty_span() )), operator: FunctionArgOperator::Assignment }, ], clauses: vec![], }), null_treatment: None, filter: None, over: None, within_group: vec![], }), expr_from_projection(only(&select.projection)) ); } #[test] fn test_array_index() { let sql = r#"SELECT ['a', 'b', 'c'][3] AS three"#; let select = duckdb().verified_only_select(sql); let projection = &select.projection; assert_eq!(1, projection.len()); let expr = match &projection[0] { SelectItem::ExprWithAlias { expr, .. } => expr, _ => panic!("Expected an expression with alias"), }; assert_eq!( &Expr::CompoundFieldAccess { root: 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()) ], named: false })), access_chain: vec![AccessExpr::Subscript(Subscript::Index { index: Expr::value(number("3")) })] }, expr ); } #[test] fn test_duckdb_union_datatype() { let sql = "CREATE TABLE tbl1 (one UNION(a INT), two UNION(a INT, b INT), nested UNION(a UNION(b INT)))"; let stmt = duckdb_and_generic().verified_stmt(sql); assert_eq!( Statement::CreateTable(CreateTable { or_replace: Default::default(), temporary: Default::default(), external: Default::default(), global: Default::default(), if_not_exists: Default::default(), transient: Default::default(), volatile: Default::default(), iceberg: Default::default(), snapshot: false, dynamic: Default::default(), name: ObjectName::from(vec!["tbl1".into()]), columns: vec![ ColumnDef { name: "one".into(), data_type: DataType::Union(vec![UnionField { field_name: "a".into(), field_type: DataType::Int(None) }]), options: Default::default() }, ColumnDef { name: "two".into(), data_type: DataType::Union(vec![ UnionField { field_name: "a".into(), field_type: DataType::Int(None) }, UnionField { field_name: "b".into(), field_type: DataType::Int(None) } ]), options: Default::default() }, ColumnDef { name: "nested".into(), data_type: DataType::Union(vec![UnionField { field_name: "a".into(), field_type: DataType::Union(vec![UnionField { field_name: "b".into(), field_type: DataType::Int(None) }]) }]), options: Default::default() } ], constraints: Default::default(), hive_distribution: HiveDistributionStyle::NONE, hive_formats: None, file_format: Default::default(), location: Default::default(), query: Default::default(), without_rowid: Default::default(), like: Default::default(), clone: Default::default(), comment: Default::default(), on_commit: Default::default(), on_cluster: Default::default(), primary_key: Default::default(), order_by: Default::default(), partition_by: Default::default(), cluster_by: Default::default(), clustered_by: Default::default(), inherits: Default::default(), partition_of: Default::default(), for_values: Default::default(), strict: Default::default(), copy_grants: Default::default(), enable_schema_evolution: Default::default(), change_tracking: Default::default(), data_retention_time_in_days: Default::default(), max_data_extension_time_in_days: Default::default(), default_ddl_collation: Default::default(), with_aggregation_policy: Default::default(), with_row_access_policy: Default::default(), with_storage_lifecycle_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, target_lag: None, warehouse: None, version: None, refresh_mode: None, initialize: None, require_user: Default::default(), diststyle: Default::default(), distkey: Default::default(), sortkey: Default::default(), backup: Default::default(), }), stmt ); } #[test] fn parse_use() { let valid_object_names = [ "mydb", "SCHEMA", "DATABASE", "CATALOG", "WAREHOUSE", "DEFAULT", ]; let quote_styles = ['"', '\'']; 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( 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( quote, object_name.to_string(), )]))) ); } } 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![ Ident::with_quote(quote, "CATALOG"), Ident::with_quote(quote, "my_schema") ]))) ); } // Test double identifier without quotes assert_eq!( duckdb().verified_stmt("USE mydb.my_schema"), Statement::Use(Use::Object(ObjectName::from(vec![ Ident::new("mydb"), Ident::new("my_schema") ]))) ); } #[test] fn test_duckdb_trim() { let real_sql = r#"SELECT customer_id, TRIM(item_price_id, '"', "a") AS item_price_id FROM models_staging.subscriptions"#; assert_eq!(duckdb().verified_stmt(real_sql).to_string(), real_sql); let sql_only_select = "SELECT TRIM('xyz', 'a')"; let select = duckdb().verified_only_select(sql_only_select); assert_eq!( &Expr::Trim { expr: Box::new(Expr::Value( Value::SingleQuotedString("xyz".to_owned()).with_empty_span() )), trim_where: None, trim_what: None, trim_characters: Some(vec![Expr::Value( Value::SingleQuotedString("a".to_owned()).with_empty_span() )]), }, expr_from_projection(only(&select.projection)) ); // missing comma separation let error_sql = "SELECT TRIM('xyz' 'a')"; assert_eq!( ParserError::ParserError("Expected: ), found: 'a'".to_owned()), duckdb().parse_sql_statements(error_sql).unwrap_err() ); } #[test] fn parse_extract_single_quotes() { let sql = "SELECT EXTRACT('month' FROM my_timestamp) FROM my_table"; duckdb().verified_stmt(sql); } #[test] fn test_duckdb_lambda_function() { // Test basic lambda with list_filter let sql = "SELECT [3, 4, 5, 6].list_filter(lambda x : x > 4)"; duckdb().verified_stmt(sql); // Test lambda with arrow syntax (also supported by DuckDB) let sql_arrow = "SELECT list_filter([1, 2, 3], x -> x > 1)"; duckdb().verified_stmt(sql_arrow); // Test lambda with multiple parameters (with index) let sql_multi = "SELECT list_filter([1, 3, 1, 5], lambda x, i : x > i)"; duckdb().verified_stmt(sql_multi); // Test lambda in list_transform let sql_transform = "SELECT list_transform([1, 2, 3], lambda x : x * 2)"; duckdb().verified_stmt(sql_transform); } apache-datafusion-sqlparser-rs-0.62.0/tests/sqlparser_hive.rs000066400000000000000000000452571517524037000243670ustar00rootroot00000000000000// 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. #![warn(clippy::all)] //! Test SQL syntax specific to Hive. The parser based on the generic dialect //! 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, }; use sqlparser::dialect::{AnsiDialect, GenericDialect, HiveDialect}; use sqlparser::parser::ParserError; use sqlparser::test_utils::*; #[test] fn parse_table_create() { let sql = r#"CREATE TABLE IF NOT EXISTS db.table (a BIGINT, b STRING, c TIMESTAMP) PARTITIONED BY (d STRING, e TIMESTAMP) STORED AS ORC LOCATION 's3://...' TBLPROPERTIES ("prop" = "2", "asdf" = '1234', 'asdf' = "1234", "asdf" = 2)"#; let iof = r#"CREATE TABLE IF NOT EXISTS db.table (a BIGINT, b STRING, c TIMESTAMP) PARTITIONED BY (d STRING, e TIMESTAMP) STORED AS INPUTFORMAT 'org.apache.hadoop.hive.ql.io.orc.OrcInputFormat' OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.orc.OrcOutputFormat' LOCATION 's3://...'"#; let serdeproperties = r#"CREATE EXTERNAL TABLE IF NOT EXISTS db.table (a STRING, b STRING, c STRING) PARTITIONED BY (d STRING, e STRING) ROW FORMAT SERDE 'org.apache.hadoop.hive.serde.config' WITH SERDEPROPERTIES ('prop_a' = 'a', 'prop_b' = 'b') STORED AS TEXTFILE LOCATION 's3://...' TBLPROPERTIES ('prop_c' = 'c')"#; let externaltable = r#"CREATE EXTERNAL TABLE t (c INT)"#; hive().verified_stmt(sql); hive().verified_stmt(iof); hive().verified_stmt(serdeproperties); hive().verified_stmt(externaltable); } #[test] fn parse_describe() { hive_and_generic().verified_stmt(r#"DESCRIBE namespace.`table`"#); hive_and_generic().verified_stmt(r#"DESCRIBE namespace.table"#); hive_and_generic().verified_stmt(r#"DESCRIBE table"#); } #[test] fn explain_describe_formatted() { hive().verified_stmt("DESCRIBE FORMATTED test.table"); } #[test] fn explain_describe_extended() { hive().verified_stmt("DESCRIBE EXTENDED test.table"); } #[test] fn parse_insert_overwrite() { let insert_partitions = r#"INSERT OVERWRITE TABLE db.new_table PARTITION (a = '1', b) SELECT a, b, c FROM db.table"#; hive().verified_stmt(insert_partitions); } #[test] fn test_truncate() { let truncate = r#"TRUNCATE TABLE db.table"#; hive().verified_stmt(truncate); } #[test] fn parse_analyze() { let analyze = r#"ANALYZE TABLE db.table_name PARTITION (a = '1234', b) COMPUTE STATISTICS NOSCAN CACHE METADATA"#; hive().verified_stmt(analyze); } #[test] fn parse_analyze_for_columns() { let analyze = r#"ANALYZE TABLE db.table_name PARTITION (a = '1234', b) COMPUTE STATISTICS FOR COLUMNS"#; hive().verified_stmt(analyze); } #[test] fn parse_msck() { let msck = r#"MSCK REPAIR TABLE db.table_name ADD PARTITIONS"#; let msck2 = r#"MSCK REPAIR TABLE db.table_name"#; hive().verified_stmt(msck); hive().verified_stmt(msck2); } #[test] fn parse_set_hivevar() { let set = "SET HIVEVAR:name = a, b, c_d"; hive().verified_stmt(set); } #[test] fn test_spaceship() { let spaceship = "SELECT * FROM db.table WHERE a <=> b"; hive().verified_stmt(spaceship); } #[test] fn parse_with_cte() { let with = "WITH a AS (SELECT * FROM b) INSERT INTO TABLE db.table_table PARTITION (a) SELECT * FROM b"; hive().verified_stmt(with); } #[test] fn drop_table_purge() { let purge = "DROP TABLE db.table_name PURGE"; hive().verified_stmt(purge); } #[test] fn create_table_like() { let like = "CREATE TABLE db.table_name LIKE db.other_table"; hive().verified_stmt(like); } #[test] fn create_table_with_comment() { let sql = concat!( "CREATE TABLE db.table_name (a INT, b STRING)", " COMMENT 'table comment'", " PARTITIONED BY (a INT, b STRING)", " CLUSTERED BY (a, b) SORTED BY (a ASC, b DESC)", " INTO 4 BUCKETS" ); match hive().verified_stmt(sql) { Statement::CreateTable(CreateTable { comment, .. }) => { assert_eq!( comment, Some(CommentDef::WithoutEq("table comment".to_string())) ) } _ => unreachable!(), } // negative test case let invalid_sql = concat!( "CREATE TABLE db.table_name (a INT, b STRING)", " PARTITIONED BY (a INT, b STRING)", " COMMENT 'table comment'", ); assert_eq!( hive().parse_sql_statements(invalid_sql).unwrap_err(), ParserError::ParserError("Expected: end of statement, found: COMMENT".to_string()) ); } #[test] fn create_table_with_clustered_by() { let sql = concat!( "CREATE TABLE db.table_name (a INT, b STRING)", " PARTITIONED BY (a INT, b STRING)", " CLUSTERED BY (a, b) SORTED BY (a ASC, b DESC)", " INTO 4 BUCKETS" ); match hive_and_generic().verified_stmt(sql) { Statement::CreateTable(CreateTable { clustered_by, .. }) => { assert_eq!( clustered_by.unwrap(), ClusteredBy { columns: vec![Ident::new("a"), Ident::new("b")], sorted_by: Some(vec![ OrderByExpr { expr: Expr::Identifier(Ident::new("a")), options: OrderByOptions { asc: Some(true), nulls_first: None, }, with_fill: None, }, OrderByExpr { expr: Expr::Identifier(Ident::new("b")), options: OrderByOptions { asc: Some(false), nulls_first: None, }, with_fill: None, }, ]), num_buckets: Value::Number("4".parse().unwrap(), false), } ) } _ => unreachable!(), } // SORTED BY is optional hive_and_generic().verified_stmt("CREATE TABLE db.table_name (a INT, b STRING) PARTITIONED BY (a INT, b STRING) CLUSTERED BY (a, b) INTO 4 BUCKETS"); // missing INTO BUCKETS assert_eq!( hive_and_generic().parse_sql_statements( "CREATE TABLE db.table_name (a INT, b STRING) PARTITIONED BY (a INT, b STRING) CLUSTERED BY (a, b)" ).unwrap_err(), ParserError::ParserError("Expected: INTO, found: EOF".to_string()) ); // missing CLUSTER BY columns assert_eq!( hive_and_generic().parse_sql_statements( "CREATE TABLE db.table_name (a INT, b STRING) PARTITIONED BY (a INT, b STRING) CLUSTERED BY () INTO 4 BUCKETS" ).unwrap_err(), ParserError::ParserError("Expected: identifier, found: )".to_string()) ); // missing SORT BY columns assert_eq!( hive_and_generic().parse_sql_statements( "CREATE TABLE db.table_name (a INT, b STRING) PARTITIONED BY (a INT, b STRING) CLUSTERED BY (a, b) SORTED BY INTO 4 BUCKETS" ).unwrap_err(), ParserError::ParserError("Expected: (, found: INTO".to_string()) ); // missing number BUCKETS assert_eq!( hive_and_generic().parse_sql_statements( "CREATE TABLE db.table_name (a INT, b STRING) PARTITIONED BY (a INT, b STRING) CLUSTERED BY (a, b) SORTED BY (a ASC, b DESC) INTO" ).unwrap_err(), ParserError::ParserError("Expected: a value, found: EOF".to_string()) ); } // Turning off this test until we can parse identifiers starting with numbers :( #[test] fn test_identifier() { let between = "SELECT a AS 3_barrr_asdf FROM db.table_name"; hive().verified_stmt(between); } #[test] fn test_alter_partition() { let alter = "ALTER TABLE db.table PARTITION (a = 2) RENAME TO PARTITION (a = 1)"; hive().verified_stmt(alter); } #[test] fn test_alter_with_location() { let alter = "ALTER TABLE db.table PARTITION (a = 2) RENAME TO PARTITION (a = 1) LOCATION 's3://...'"; hive().verified_stmt(alter); } #[test] fn test_alter_with_set_location() { let alter = "ALTER TABLE db.table PARTITION (a = 2) RENAME TO PARTITION (a = 1) SET LOCATION 's3://...'"; hive().verified_stmt(alter); } #[test] fn test_add_partition() { let add = "ALTER TABLE db.table ADD IF NOT EXISTS PARTITION (a = 'asdf', b = 2)"; hive().verified_stmt(add); } #[test] fn test_add_multiple_partitions() { let add = "ALTER TABLE db.table ADD IF NOT EXISTS PARTITION (`a` = 'asdf', `b` = 2) PARTITION (`a` = 'asdh', `b` = 3)"; hive().verified_stmt(add); } #[test] fn test_drop_partition() { let drop = "ALTER TABLE db.table DROP PARTITION (a = 1)"; hive().verified_stmt(drop); } #[test] fn test_drop_if_exists() { let drop = "ALTER TABLE db.table DROP IF EXISTS PARTITION (a = 'b', c = 'd')"; hive().verified_stmt(drop); } #[test] fn test_cluster_by() { let cluster = "SELECT a FROM db.table CLUSTER BY a, b"; hive().verified_stmt(cluster); } #[test] fn test_distribute_by() { let cluster = "SELECT a FROM db.table DISTRIBUTE BY a, b"; hive().verified_stmt(cluster); } #[test] fn no_join_condition() { let join = "SELECT a, b FROM db.table_name JOIN a"; hive().verified_stmt(join); } #[test] fn columns_after_partition() { let query = "INSERT INTO db.table_name PARTITION (a, b) (c, d) SELECT a, b, c, d FROM db.table"; hive().verified_stmt(query); } #[test] fn long_numerics() { let query = r#"SELECT MIN(MIN(10, 5), 1L) AS a"#; hive().verified_stmt(query); } #[test] fn decimal_precision() { let query = "SELECT CAST(a AS DECIMAL(18,2)) FROM db.table"; hive().verified_stmt(query); } #[test] fn create_temp_table() { let query = "CREATE TEMPORARY TABLE db.table (a INT NOT NULL)"; let query2 = "CREATE TEMP TABLE db.table (a INT NOT NULL)"; hive().verified_stmt(query); hive().one_statement_parses_to(query2, query); } #[test] fn create_delimited_table() { let query = "CREATE TABLE tab (cola STRING, colb BIGINT) ROW FORMAT DELIMITED FIELDS TERMINATED BY '\t' ESCAPED BY '\"' MAP KEYS TERMINATED BY '\"'"; hive().verified_stmt(query); } #[test] fn create_local_directory() { let query = "INSERT OVERWRITE LOCAL DIRECTORY '/home/blah' STORED AS TEXTFILE SELECT * FROM db.table"; hive().verified_stmt(query); } #[test] fn lateral_view() { let view = "SELECT a FROM db.table LATERAL VIEW explode(a) t AS j, P LATERAL VIEW OUTER explode(a) t AS a, b WHERE a = 1"; hive().verified_stmt(view); } #[test] 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] fn rename_table() { let rename = "ALTER TABLE db.table_name RENAME TO db.table_2"; hive().verified_stmt(rename); } #[test] fn map_access() { let rename = r#"SELECT a.b["asdf"] FROM db.table WHERE a = 2"#; hive().verified_stmt(rename); } #[test] fn from_cte() { let rename = "WITH cte AS (SELECT * FROM a.b) FROM cte INSERT INTO TABLE a.b PARTITION (a) SELECT *"; println!("{}", hive().verified_stmt(rename)); } #[test] fn set_statement_with_minus() { assert_eq!( hive().verified_stmt("SET hive.tez.java.opts = -Xmx4g"), Statement::Set(Set::SingleAssignment { scope: None, hivevar: false, variable: ObjectName::from(vec![ Ident::new("hive"), Ident::new("tez"), Ident::new("java"), Ident::new("opts") ]), values: vec![Expr::UnaryOp { op: UnaryOperator::Minus, expr: Box::new(Expr::Identifier(Ident::new("Xmx4g"))) }], }) ); assert_eq!( hive().parse_sql_statements("SET hive.tez.java.opts = -"), Err(ParserError::ParserError( "Expected: variable value, found: EOF".to_string() )) ) } #[test] 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 { temporary, name, function_body, using, .. }) => { assert!(temporary); assert_eq!(name.to_string(), "mydb.myfunc"); assert_eq!( function_body, Some(CreateFunctionBody::AsBeforeOptions { body: Expr::Value( (Value::SingleQuotedString("org.random.class.Name".to_string())) .with_empty_span() ), link_symbol: None, }) ); assert_eq!( using, Some(CreateFunctionUsing::Jar( "hdfs://somewhere.com:8020/very/far".to_string() )), ) } _ => unreachable!(), } // Test error in dialect that doesn't support parsing CREATE FUNCTION let unsupported_dialects = TestedDialects::new(vec![Box::new(AnsiDialect {})]); assert_eq!( unsupported_dialects.parse_sql_statements(sql).unwrap_err(), ParserError::ParserError( "Expected: an object type after CREATE, found: FUNCTION".to_string() ) ); let sql = "CREATE TEMPORARY FUNCTION mydb.myfunc AS 'org.random.class.Name' USING JAR"; assert_eq!( hive().parse_sql_statements(sql).unwrap_err(), ParserError::ParserError("Expected: literal string, found: EOF".to_string()), ); } #[test] fn filter_as_alias() { let sql = "SELECT name filter FROM region"; let expected = "SELECT name AS filter FROM region"; println!("{}", hive().one_statement_parses_to(sql, expected)); } #[test] fn parse_delimited_identifiers() { // check that quoted identifiers in any position remain quoted after serialization let select = hive().verified_only_select( r#"SELECT "alias"."bar baz", "myfun"(), "simple id" AS "column alias" FROM "a table" AS "alias""#, ); // check FROM match only(select.from).relation { TableFactor::Table { name, alias, args, with_hints, version, with_ordinality: _, partitions: _, json_path: _, sample: _, index_hints: _, } => { assert_eq!( ObjectName::from(vec![Ident::with_quote('"', "a table")]), name ); assert_eq!(Ident::with_quote('"', "alias"), alias.unwrap().name); assert!(args.is_none()); assert!(with_hints.is_empty()); assert!(version.is_none()); } _ => panic!("Expecting TableFactor::Table"), } // check SELECT assert_eq!(3, select.projection.len()); assert_eq!( &Expr::CompoundIdentifier(vec![ Ident::with_quote('"', "alias"), Ident::with_quote('"', "bar baz"), ]), expr_from_projection(&select.projection[0]), ); assert_eq!( &Expr::Function(Function { name: ObjectName::from(vec![Ident::with_quote('"', "myfun")]), uses_odbc_syntax: false, parameters: FunctionArguments::None, args: FunctionArguments::List(FunctionArgumentList { duplicate_treatment: None, args: vec![], clauses: vec![], }), null_treatment: None, filter: None, over: None, within_group: vec![], }), expr_from_projection(&select.projection[1]), ); match &select.projection[2] { SelectItem::ExprWithAlias { expr, alias } => { assert_eq!(&Expr::Identifier(Ident::with_quote('"', "simple id")), expr); assert_eq!(&Ident::with_quote('"', "column alias"), alias); } _ => panic!("Expected: ExprWithAlias"), } hive().verified_stmt(r#"CREATE TABLE "foo" ("bar" "int")"#); hive().verified_stmt(r#"ALTER TABLE foo ADD CONSTRAINT "bar" PRIMARY KEY (baz)"#); //TODO verified_stmt(r#"UPDATE foo SET "bar" = 5"#); } #[test] fn parse_use() { let valid_object_names = ["mydb", "SCHEMA", "DATABASE", "CATALOG", "WAREHOUSE"]; let quote_styles = ['\'', '"', '`']; 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( 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( quote, object_name.to_string(), )]))) ); } } // Test DEFAULT keyword that is special case in Hive assert_eq!( hive().verified_stmt("USE DEFAULT"), Statement::Use(Use::Default) ); } #[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 {})]) } fn hive_and_generic() -> TestedDialects { TestedDialects::new(vec![Box::new(HiveDialect {}), Box::new(GenericDialect {})]) } apache-datafusion-sqlparser-rs-0.62.0/tests/sqlparser_mssql.rs000066400000000000000000003123101517524037000245560ustar00rootroot00000000000000// 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. #![warn(clippy::all)] //! Test SQL syntax specific to Microsoft's T-SQL. The parser based on the //! generic dialect is also tested (on the inputs it can handle). #[macro_use] mod test_utils; use helpers::attached_token::AttachedToken; use sqlparser::keywords::Keyword; use sqlparser::tokenizer::{Location, Span, Token, TokenWithSpan, Word}; use test_utils::*; use sqlparser::ast::DataType::{Int, Text, Varbinary}; use sqlparser::ast::DeclareAssignment::MsSqlAssignment; use sqlparser::ast::Value::SingleQuotedString; use sqlparser::ast::*; use sqlparser::dialect::{GenericDialect, MsSqlDialect}; use sqlparser::parser::{Parser, ParserError, ParserOptions}; #[test] fn parse_mssql_identifiers() { let sql = "SELECT @@version, _foo$123 FROM ##temp"; let select = ms_and_generic().verified_only_select(sql); assert_eq!( &Expr::Identifier(Ident::new("@@version")), expr_from_projection(&select.projection[0]), ); assert_eq!( &Expr::Identifier(Ident::new("_foo$123")), expr_from_projection(&select.projection[1]), ); assert_eq!(2, select.projection.len()); match &only(&select.from).relation { TableFactor::Table { name, .. } => { assert_eq!("##temp".to_string(), name.to_string()); } _ => unreachable!(), }; } #[test] fn parse_table_time_travel() { let version = "2023-08-18 23:08:18".to_string(); let sql = format!("SELECT 1 FROM t1 FOR SYSTEM_TIME AS OF '{version}'"); let select = ms().verified_only_select(&sql); assert_eq!( select.from, vec![TableWithJoins { relation: TableFactor::Table { name: ObjectName::from(vec![Ident::new("t1")]), alias: None, args: None, with_hints: vec![], version: Some(TableVersion::ForSystemTimeAsOf(Expr::Value( (Value::SingleQuotedString(version)).with_empty_span() ))), partitions: vec![], with_ordinality: false, json_path: None, sample: None, index_hints: vec![] }, joins: vec![] },] ); let sql = "SELECT 1 FROM t1 FOR SYSTEM TIME AS OF 'some_timestamp'".to_string(); assert!(ms().parse_sql_statements(&sql).is_err()); } #[test] fn parse_mssql_single_quoted_aliases() { let _ = ms_and_generic().one_statement_parses_to("SELECT foo 'alias'", "SELECT foo AS 'alias'"); } #[test] fn parse_mssql_delimited_identifiers() { let s = ms().one_statement_parses_to( "SELECT [a.b!] [FROM] FROM foo [WHERE]", "SELECT [a.b!] AS [FROM] FROM foo [WHERE]", ); if let Statement::Query(q) = s { match &q.body.as_select().expect("not a SELECT").from[..] { [from] => match &from.relation { TableFactor::Table { name, alias, .. } => { assert_eq!(&format!("{name}"), "foo"); assert_eq!( alias, &Some(TableAlias { explicit: false, name: Ident::with_quote('[', "WHERE"), columns: vec![], at: None, }) ); } _ => panic!("unexpected FROM type"), }, _ => panic!("unexpected number of FROMs"), } } else { panic!("statement not parsed as QUERY"); } } #[test] fn parse_create_procedure() { let sql = "CREATE OR ALTER PROCEDURE test (@foo INT, @bar VARCHAR(256)) AS BEGIN SELECT 1; END"; assert_eq!( ms().verified_stmt(sql), Statement::CreateProcedure { or_alter: true, body: ConditionalStatements::BeginEnd(BeginEndStatements { begin_token: AttachedToken::empty(), statements: vec![Statement::Query(Box::new(Query { with: None, limit_clause: None, fetch: None, locks: vec![], for_clause: None, order_by: None, settings: None, format_clause: None, pipe_operators: vec![], body: Box::new(SetExpr::Select(Box::new(Select { select_token: AttachedToken::empty(), optimizer_hints: vec![], distinct: None, select_modifiers: None, top: None, top_before_distinct: false, projection: vec![SelectItem::UnnamedExpr(Expr::Value( (number("1")).with_empty_span() ))], exclude: None, into: None, from: vec![], lateral_views: vec![], prewhere: None, selection: None, group_by: GroupByExpr::Expressions(vec![], vec![]), cluster_by: vec![], distribute_by: vec![], sort_by: vec![], having: None, named_window: vec![], window_before_qualify: false, qualify: None, value_table_mode: None, connect_by: vec![], flavor: SelectFlavor::Standard, }))) }))], end_token: AttachedToken::empty(), }), params: Some(vec![ ProcedureParam { name: Ident { value: "@foo".into(), quote_style: None, span: Span::empty(), }, data_type: DataType::Int(None), mode: None, default: None, }, ProcedureParam { name: Ident { value: "@bar".into(), quote_style: None, span: Span::empty(), }, data_type: DataType::Varchar(Some(CharacterLength::IntegerLength { length: 256, unit: None })), mode: None, default: None, } ]), name: ObjectName::from(vec![Ident { value: "test".into(), quote_style: None, span: Span::empty(), }]), language: None, } ) } #[test] fn parse_mssql_create_procedure() { let _ = ms_and_generic().verified_stmt("CREATE OR ALTER PROCEDURE foo AS SELECT 1;"); let _ = ms_and_generic().verified_stmt("CREATE OR ALTER PROCEDURE foo AS BEGIN SELECT 1; END"); let _ = ms_and_generic().verified_stmt("CREATE PROCEDURE foo AS BEGIN SELECT 1; END"); let _ = ms().verified_stmt( "CREATE PROCEDURE foo AS BEGIN SELECT [myColumn] FROM [myschema].[mytable]; END", ); let _ = ms_and_generic().verified_stmt( "CREATE PROCEDURE foo (@CustomerName NVARCHAR(50)) AS BEGIN SELECT * FROM DEV; END", ); let _ = ms().verified_stmt("CREATE PROCEDURE [foo] AS BEGIN UPDATE bar SET col = 'test'; END"); // Test a statement with END in it let _ = ms().verified_stmt("CREATE PROCEDURE [foo] AS BEGIN SELECT [foo], CASE WHEN [foo] IS NULL THEN 'empty' ELSE 'notempty' END AS [foo]; END"); // Multiple statements let _ = ms().verified_stmt("CREATE PROCEDURE [foo] AS BEGIN UPDATE bar SET col = 'test'; SELECT [foo] FROM BAR WHERE [FOO] > 10; END"); // parameters with default values let sql = r#"CREATE PROCEDURE foo (IN @a INTEGER = 1, OUT @b TEXT = '2', INOUT @c DATETIME = NULL, @d BOOL = 0) AS BEGIN SELECT 1; END"#; let _ = ms().verified_stmt(sql); } #[test] fn parse_create_function() { let return_expression_function = "CREATE FUNCTION some_scalar_udf(@foo INT, @bar VARCHAR(256)) RETURNS INT AS BEGIN RETURN 1; END"; assert_eq!( ms().verified_stmt(return_expression_function), sqlparser::ast::Statement::CreateFunction(CreateFunction { or_alter: false, or_replace: false, temporary: false, if_not_exists: false, name: ObjectName::from(vec![Ident::new("some_scalar_udf")]), args: Some(vec![ OperateFunctionArg { mode: None, name: Some(Ident::new("@foo")), data_type: DataType::Int(None), default_expr: None, }, OperateFunctionArg { mode: None, name: Some(Ident::new("@bar")), data_type: DataType::Varchar(Some(CharacterLength::IntegerLength { length: 256, unit: None })), default_expr: None, }, ]), return_type: Some(FunctionReturnType::DataType(DataType::Int(None))), function_body: Some(CreateFunctionBody::AsBeginEnd(BeginEndStatements { begin_token: AttachedToken::empty(), statements: vec![Statement::Return(ReturnStatement { value: Some(ReturnStatementValue::Expr(Expr::Value( (number("1")).with_empty_span() ))), })], end_token: AttachedToken::empty(), })), behavior: None, called_on_null: None, parallel: None, security: None, set_params: vec![], using: None, language: None, determinism_specifier: None, options: None, remote_connection: None, }), ); let multi_statement_function = "\ CREATE FUNCTION some_scalar_udf(@foo INT, @bar VARCHAR(256)) \ RETURNS INT \ AS \ BEGIN \ SET @foo = @foo + 1; \ RETURN @foo; \ END\ "; let _ = ms().verified_stmt(multi_statement_function); let multi_statement_function_without_as = multi_statement_function.replace(" AS", ""); let _ = ms().one_statement_parses_to( &multi_statement_function_without_as, multi_statement_function, ); let create_function_with_conditional = "\ CREATE FUNCTION some_scalar_udf() \ RETURNS INT \ AS \ BEGIN \ IF 1 = 2 \ BEGIN \ RETURN 1; \ END; \ RETURN 0; \ END\ "; let _ = ms().verified_stmt(create_function_with_conditional); let create_or_alter_function = "\ CREATE OR ALTER FUNCTION some_scalar_udf(@foo INT, @bar VARCHAR(256)) \ RETURNS INT \ AS \ BEGIN \ SET @foo = @foo + 1; \ RETURN @foo; \ END\ "; let _ = ms().verified_stmt(create_or_alter_function); let create_function_with_return_expression = "\ CREATE FUNCTION some_scalar_udf(@foo INT, @bar VARCHAR(256)) \ RETURNS INT \ AS \ BEGIN \ RETURN CONVERT(INT, 1) + 2; \ END\ "; let _ = ms().verified_stmt(create_function_with_return_expression); let create_inline_table_value_function = "\ CREATE FUNCTION some_inline_tvf(@foo INT, @bar VARCHAR(256)) \ RETURNS TABLE \ AS \ RETURN (SELECT 1 AS col_1)\ "; let _ = ms().verified_stmt(create_inline_table_value_function); let create_inline_table_value_function_without_parentheses = "\ CREATE FUNCTION some_inline_tvf(@foo INT, @bar VARCHAR(256)) \ RETURNS TABLE \ AS \ RETURN SELECT 1 AS col_1\ "; let _ = ms().verified_stmt(create_inline_table_value_function_without_parentheses); let create_inline_table_value_function_without_as = create_inline_table_value_function.replace(" AS", ""); let _ = ms().one_statement_parses_to( &create_inline_table_value_function_without_as, create_inline_table_value_function, ); let create_multi_statement_table_value_function = "\ CREATE FUNCTION some_multi_statement_tvf(@foo INT, @bar VARCHAR(256)) \ RETURNS @t TABLE (col_1 INT) \ AS \ BEGIN \ INSERT INTO @t SELECT 1; \ RETURN; \ END\ "; let _ = ms().verified_stmt(create_multi_statement_table_value_function); let create_multi_statement_table_value_function_without_as = create_multi_statement_table_value_function.replace(" AS", ""); let _ = ms().one_statement_parses_to( &create_multi_statement_table_value_function_without_as, create_multi_statement_table_value_function, ); let create_multi_statement_table_value_function_with_constraints = "\ CREATE FUNCTION some_multi_statement_tvf(@foo INT, @bar VARCHAR(256)) \ RETURNS @t TABLE (col_1 INT NOT NULL) \ AS \ BEGIN \ INSERT INTO @t SELECT 1; \ RETURN @t; \ END\ "; let _ = ms().verified_stmt(create_multi_statement_table_value_function_with_constraints); let create_multi_statement_tvf_without_table_definition = "\ CREATE FUNCTION incorrect_tvf(@foo INT, @bar VARCHAR(256)) \ RETURNS @t TABLE () AS \ BEGIN \ INSERT INTO @t SELECT 1; \ RETURN @t; \ END\ "; assert_eq!( ParserError::ParserError("Unparsable function body".to_owned()), ms().parse_sql_statements(create_multi_statement_tvf_without_table_definition) .unwrap_err() ); let create_inline_tvf_without_subquery_or_bare_select = "\ CREATE FUNCTION incorrect_tvf(@foo INT, @bar VARCHAR(256)) \ RETURNS TABLE AS \ RETURN 'hi'\ "; assert_eq!( ParserError::ParserError( "Expected a subquery (or bare SELECT statement) after RETURN".to_owned() ), ms().parse_sql_statements(create_inline_tvf_without_subquery_or_bare_select) .unwrap_err() ); } #[test] fn parse_create_function_parameter_default_values() { let single_default_sql = "CREATE FUNCTION test_func(@param1 INT = 42) RETURNS INT AS BEGIN RETURN @param1; END"; assert_eq!( ms().verified_stmt(single_default_sql), Statement::CreateFunction(CreateFunction { or_alter: false, or_replace: false, temporary: false, if_not_exists: false, name: ObjectName::from(vec![Ident::new("test_func")]), args: Some(vec![OperateFunctionArg { mode: None, name: Some(Ident::new("@param1")), data_type: DataType::Int(None), default_expr: Some(Expr::Value((number("42")).with_empty_span())), },]), return_type: Some(FunctionReturnType::DataType(DataType::Int(None))), function_body: Some(CreateFunctionBody::AsBeginEnd(BeginEndStatements { begin_token: AttachedToken::empty(), statements: vec![Statement::Return(ReturnStatement { value: Some(ReturnStatementValue::Expr(Expr::Identifier(Ident::new( "@param1" )))), })], end_token: AttachedToken::empty(), })), behavior: None, called_on_null: None, parallel: None, security: None, set_params: vec![], using: None, language: None, determinism_specifier: None, options: None, remote_connection: None, }), ); } #[test] fn parse_mssql_apply_join() { let _ = ms_and_generic().verified_only_select( "SELECT * FROM sys.dm_exec_query_stats AS deqs \ CROSS APPLY sys.dm_exec_query_plan(deqs.plan_handle)", ); let _ = ms_and_generic().verified_only_select( "SELECT * FROM sys.dm_exec_query_stats AS deqs \ OUTER APPLY sys.dm_exec_query_plan(deqs.plan_handle)", ); let _ = ms_and_generic().verified_only_select( "SELECT * FROM foo \ OUTER APPLY (SELECT foo.x + 1) AS bar", ); } #[test] fn parse_mssql_openjson() { let select = ms().verified_only_select( "SELECT B.kind, B.id_list \ FROM t_test_table AS A \ CROSS APPLY OPENJSON(A.param, '$.config') WITH (kind VARCHAR(20) '$.kind', [id_list] NVARCHAR(MAX) '$.id_list' AS JSON) AS B", ); assert_eq!( vec![TableWithJoins { relation: TableFactor::Table { name: ObjectName::from(vec![Ident::new("t_test_table")]), alias: table_alias(true, "A"), args: None, with_hints: vec![], version: None, with_ordinality: false, partitions: vec![], json_path: None, sample: None, index_hints: vec![] }, joins: vec![Join { relation: TableFactor::OpenJsonTable { json_expr: Expr::CompoundIdentifier( vec![Ident::new("A"), Ident::new("param"),] ), json_path: Some(Value::SingleQuotedString("$.config".into()).with_empty_span()), columns: vec![ OpenJsonTableColumn { name: Ident::new("kind"), r#type: DataType::Varchar(Some(CharacterLength::IntegerLength { length: 20, unit: None })), path: Some("$.kind".into()), as_json: false }, OpenJsonTableColumn { name: Ident { value: "id_list".into(), quote_style: Some('['), span: Span::empty(), }, r#type: DataType::Nvarchar(Some(CharacterLength::Max)), path: Some("$.id_list".into()), as_json: true } ], alias: table_alias(true, "B") }, global: false, join_operator: JoinOperator::CrossApply }] }], select.from ); let select = ms().verified_only_select( "SELECT B.kind, B.id_list \ FROM t_test_table AS A \ CROSS APPLY OPENJSON(A.param) WITH (kind VARCHAR(20) '$.kind', [id_list] NVARCHAR(MAX) '$.id_list' AS JSON) AS B", ); assert_eq!( vec![TableWithJoins { relation: TableFactor::Table { name: ObjectName::from(vec![Ident::new("t_test_table"),]), alias: table_alias(true, "A"), args: None, with_hints: vec![], version: None, with_ordinality: false, partitions: vec![], json_path: None, sample: None, index_hints: vec![] }, joins: vec![Join { relation: TableFactor::OpenJsonTable { json_expr: Expr::CompoundIdentifier( vec![Ident::new("A"), Ident::new("param"),] ), json_path: None, columns: vec![ OpenJsonTableColumn { name: Ident::new("kind"), r#type: DataType::Varchar(Some(CharacterLength::IntegerLength { length: 20, unit: None })), path: Some("$.kind".into()), as_json: false }, OpenJsonTableColumn { name: Ident { value: "id_list".into(), quote_style: Some('['), span: Span::empty(), }, r#type: DataType::Nvarchar(Some(CharacterLength::Max)), path: Some("$.id_list".into()), as_json: true } ], alias: table_alias(true, "B") }, global: false, join_operator: JoinOperator::CrossApply }] }], select.from ); let select = ms().verified_only_select( "SELECT B.kind, B.id_list \ FROM t_test_table AS A \ CROSS APPLY OPENJSON(A.param) WITH (kind VARCHAR(20), [id_list] NVARCHAR(MAX)) AS B", ); assert_eq!( vec![TableWithJoins { relation: TableFactor::Table { name: ObjectName::from(vec![Ident::new("t_test_table")]), alias: table_alias(true, "A"), args: None, with_hints: vec![], version: None, with_ordinality: false, partitions: vec![], json_path: None, sample: None, index_hints: vec![] }, joins: vec![Join { relation: TableFactor::OpenJsonTable { json_expr: Expr::CompoundIdentifier( vec![Ident::new("A"), Ident::new("param"),] ), json_path: None, columns: vec![ OpenJsonTableColumn { name: Ident::new("kind"), r#type: DataType::Varchar(Some(CharacterLength::IntegerLength { length: 20, unit: None })), path: None, as_json: false }, OpenJsonTableColumn { name: Ident { value: "id_list".into(), quote_style: Some('['), span: Span::empty(), }, r#type: DataType::Nvarchar(Some(CharacterLength::Max)), path: None, as_json: false } ], alias: table_alias(true, "B") }, global: false, join_operator: JoinOperator::CrossApply }] }], select.from ); let select = ms_and_generic().verified_only_select( "SELECT B.kind, B.id_list \ FROM t_test_table AS A \ CROSS APPLY OPENJSON(A.param, '$.config') AS B", ); assert_eq!( vec![TableWithJoins { relation: TableFactor::Table { name: ObjectName::from(vec![Ident::new("t_test_table")]), alias: table_alias(true, "A"), args: None, with_hints: vec![], version: None, with_ordinality: false, partitions: vec![], json_path: None, sample: None, index_hints: vec![], }, joins: vec![Join { relation: TableFactor::OpenJsonTable { json_expr: Expr::CompoundIdentifier( vec![Ident::new("A"), Ident::new("param"),] ), json_path: Some(Value::SingleQuotedString("$.config".into()).with_empty_span()), columns: vec![], alias: table_alias(true, "B") }, global: false, join_operator: JoinOperator::CrossApply }] }], select.from ); let select = ms_and_generic().verified_only_select( "SELECT B.kind, B.id_list \ FROM t_test_table AS A \ CROSS APPLY OPENJSON(A.param) AS B", ); assert_eq!( vec![TableWithJoins { relation: TableFactor::Table { name: ObjectName::from(vec![Ident::new("t_test_table")]), alias: table_alias(true, "A"), args: None, with_hints: vec![], version: None, with_ordinality: false, partitions: vec![], json_path: None, sample: None, index_hints: vec![], }, joins: vec![Join { relation: TableFactor::OpenJsonTable { json_expr: Expr::CompoundIdentifier( vec![Ident::new("A"), Ident::new("param"),] ), json_path: None, columns: vec![], alias: table_alias(true, "B") }, global: false, join_operator: JoinOperator::CrossApply }] }], select.from ); } #[test] fn parse_mssql_top_paren() { let sql = "SELECT TOP (5) * FROM foo"; let select = ms_and_generic().verified_only_select(sql); let top = select.top.unwrap(); assert_eq!( Some(TopQuantity::Expr(Expr::Value( (number("5")).with_empty_span() ))), top.quantity ); assert!(!top.percent); } #[test] fn parse_mssql_top_percent() { let sql = "SELECT TOP (5) PERCENT * FROM foo"; let select = ms_and_generic().verified_only_select(sql); let top = select.top.unwrap(); assert_eq!( Some(TopQuantity::Expr(Expr::Value( (number("5")).with_empty_span() ))), top.quantity ); assert!(top.percent); } #[test] fn parse_mssql_top_with_ties() { let sql = "SELECT TOP (5) WITH TIES * FROM foo"; let select = ms_and_generic().verified_only_select(sql); let top = select.top.unwrap(); assert_eq!( Some(TopQuantity::Expr(Expr::Value( (number("5")).with_empty_span() ))), top.quantity ); assert!(top.with_ties); } #[test] fn parse_mssql_top_percent_with_ties() { let sql = "SELECT TOP (10) PERCENT WITH TIES * FROM foo"; let select = ms_and_generic().verified_only_select(sql); let top = select.top.unwrap(); assert_eq!( Some(TopQuantity::Expr(Expr::Value( (number("10")).with_empty_span() ))), top.quantity ); assert!(top.percent); } #[test] fn parse_mssql_top() { let sql = "SELECT TOP 5 bar, baz FROM foo"; let _ = ms_and_generic().one_statement_parses_to(sql, "SELECT TOP 5 bar, baz FROM foo"); } #[test] fn parse_mssql_bin_literal() { let _ = ms_and_generic().one_statement_parses_to("SELECT 0xdeadBEEF", "SELECT X'deadBEEF'"); } #[test] fn parse_mssql_create_role() { let sql = "CREATE ROLE mssql AUTHORIZATION helena"; match ms().verified_stmt(sql) { Statement::CreateRole(create_role) => { assert_eq_vec(&["mssql"], &create_role.names); assert_eq!( create_role.authorization_owner, Some(ObjectName::from(vec![Ident { value: "helena".into(), quote_style: None, span: Span::empty(), }])) ); } _ => unreachable!(), } } #[test] fn parse_alter_role() { let sql = "ALTER ROLE old_name WITH NAME = new_name"; assert_eq!( ms().parse_sql_statements(sql).unwrap(), [Statement::AlterRole { name: Ident { value: "old_name".into(), quote_style: None, span: Span::empty(), }, operation: AlterRoleOperation::RenameRole { role_name: Ident { value: "new_name".into(), quote_style: None, span: Span::empty(), } }, }] ); let sql = "ALTER ROLE role_name ADD MEMBER new_member"; assert_eq!( ms().verified_stmt(sql), Statement::AlterRole { name: Ident { value: "role_name".into(), quote_style: None, span: Span::empty(), }, operation: AlterRoleOperation::AddMember { member_name: Ident { value: "new_member".into(), quote_style: None, span: Span::empty(), } }, } ); let sql = "ALTER ROLE role_name DROP MEMBER old_member"; assert_eq!( ms().verified_stmt(sql), Statement::AlterRole { name: Ident { value: "role_name".into(), quote_style: None, span: Span::empty(), }, operation: AlterRoleOperation::DropMember { member_name: Ident { value: "old_member".into(), quote_style: None, span: Span::empty(), } }, } ); } #[test] fn parse_delimited_identifiers() { // check that quoted identifiers in any position remain quoted after serialization let select = ms_and_generic().verified_only_select( r#"SELECT "alias"."bar baz", "myfun"(), "simple id" AS "column alias" FROM "a table" AS "alias""#, ); // check FROM match only(select.from).relation { TableFactor::Table { name, alias, args, with_hints, version, .. } => { assert_eq!( ObjectName::from(vec![Ident::with_quote('"', "a table")]), name ); assert_eq!(Ident::with_quote('"', "alias"), alias.unwrap().name); assert!(args.is_none()); assert!(with_hints.is_empty()); assert!(version.is_none()); } _ => panic!("Expecting TableFactor::Table"), } // check SELECT assert_eq!(3, select.projection.len()); assert_eq!( &Expr::CompoundIdentifier(vec![ Ident::with_quote('"', "alias"), Ident::with_quote('"', "bar baz"), ]), expr_from_projection(&select.projection[0]), ); assert_eq!( &Expr::Function(Function { name: ObjectName::from(vec![Ident::with_quote('"', "myfun")]), uses_odbc_syntax: false, parameters: FunctionArguments::None, args: FunctionArguments::List(FunctionArgumentList { duplicate_treatment: None, args: vec![], clauses: vec![], }), null_treatment: None, filter: None, over: None, within_group: vec![], }), expr_from_projection(&select.projection[1]), ); match &select.projection[2] { SelectItem::ExprWithAlias { expr, alias } => { assert_eq!(&Expr::Identifier(Ident::with_quote('"', "simple id")), expr); assert_eq!(&Ident::with_quote('"', "column alias"), alias); } _ => panic!("Expected ExprWithAlias"), } ms_and_generic().verified_stmt(r#"CREATE TABLE "foo" ("bar" "int")"#); ms_and_generic().verified_stmt(r#"ALTER TABLE foo ADD CONSTRAINT "bar" PRIMARY KEY (baz)"#); //TODO verified_stmt(r#"UPDATE foo SET "bar" = 5"#); } #[test] fn parse_table_name_in_square_brackets() { let select = ms().verified_only_select(r#"SELECT [a column] FROM [a schema].[a table]"#); if let TableFactor::Table { name, .. } = only(select.from).relation { assert_eq!( ObjectName::from(vec![ Ident::with_quote('[', "a schema"), Ident::with_quote('[', "a table") ]), name ); } else { panic!("Expecting TableFactor::Table"); } assert_eq!( &Expr::Identifier(Ident::with_quote('[', "a column")), expr_from_projection(&select.projection[0]), ); } #[test] fn parse_for_clause() { ms_and_generic().verified_stmt("SELECT a FROM t FOR JSON PATH"); ms_and_generic().verified_stmt("SELECT b FROM t FOR JSON AUTO"); ms_and_generic().verified_stmt("SELECT c FROM t FOR JSON AUTO, WITHOUT_ARRAY_WRAPPER"); ms_and_generic().verified_stmt("SELECT 1 FROM t FOR JSON PATH, ROOT('x'), INCLUDE_NULL_VALUES"); ms_and_generic().verified_stmt("SELECT 2 FROM t FOR XML AUTO"); ms_and_generic().verified_stmt("SELECT 3 FROM t FOR XML AUTO, TYPE, ELEMENTS"); ms_and_generic().verified_stmt("SELECT * FROM t WHERE x FOR XML AUTO, ELEMENTS"); ms_and_generic().verified_stmt("SELECT x FROM t ORDER BY y FOR XML AUTO, ELEMENTS"); ms_and_generic().verified_stmt("SELECT y FROM t FOR XML PATH('x'), ROOT('y'), ELEMENTS"); ms_and_generic().verified_stmt("SELECT z FROM t FOR XML EXPLICIT, BINARY BASE64"); ms_and_generic().verified_stmt("SELECT * FROM t FOR XML RAW('x')"); ms_and_generic().verified_stmt("SELECT * FROM t FOR BROWSE"); } #[test] fn dont_parse_trailing_for() { assert!(ms() .run_parser_method("SELECT * FROM foo FOR", |p| p.parse_query()) .is_err()); } #[test] fn parse_for_json_expect_ast() { assert_eq!( ms().verified_query("SELECT * FROM t FOR JSON PATH, ROOT('root')") .for_clause .unwrap(), ForClause::Json { for_json: ForJson::Path, root: Some("root".into()), without_array_wrapper: false, include_null_values: false, } ); } #[test] fn parse_mssql_json_object() { let select = ms().verified_only_select( "SELECT JSON_OBJECT('user_name' : USER_NAME(), LOWER(@id_key) : @id_value, 'sid' : (SELECT @@SPID) ABSENT ON NULL)", ); match expr_from_projection(&select.projection[0]) { Expr::Function(Function { args: FunctionArguments::List(FunctionArgumentList { args, clauses, .. }), .. }) => { assert!(matches!( args[0], FunctionArg::ExprNamed { name: Expr::Value(ValueWithSpan { value: Value::SingleQuotedString(_), span: _ }), arg: FunctionArgExpr::Expr(Expr::Function(_)), operator: FunctionArgOperator::Colon } )); assert!(matches!( args[1], FunctionArg::ExprNamed { name: Expr::Function(_), arg: FunctionArgExpr::Expr(Expr::Identifier(_)), operator: FunctionArgOperator::Colon } )); assert!(matches!( args[2], FunctionArg::ExprNamed { name: Expr::Value(ValueWithSpan { value: Value::SingleQuotedString(_), span: _ }), arg: FunctionArgExpr::Expr(Expr::Subquery(_)), operator: FunctionArgOperator::Colon } )); assert_eq!( &[FunctionArgumentClause::JsonNullClause( JsonNullClause::AbsentOnNull )], &clauses[..] ); } _ => unreachable!(), } let select = ms().verified_only_select( "SELECT s.session_id, JSON_OBJECT('security_id' : s.security_id, 'login' : s.login_name, 'status' : s.status) AS info \ FROM sys.dm_exec_sessions AS s \ WHERE s.is_user_process = 1", ); match &select.projection[1] { SelectItem::ExprWithAlias { expr: Expr::Function(Function { args: FunctionArguments::List(FunctionArgumentList { args, .. }), .. }), .. } => { assert!(matches!( args[0], FunctionArg::ExprNamed { name: Expr::Value(ValueWithSpan { value: Value::SingleQuotedString(_), span: _ }), arg: FunctionArgExpr::Expr(Expr::CompoundIdentifier(_)), operator: FunctionArgOperator::Colon } )); assert!(matches!( args[1], FunctionArg::ExprNamed { name: Expr::Value(ValueWithSpan { value: Value::SingleQuotedString(_), span: _ }), arg: FunctionArgExpr::Expr(Expr::CompoundIdentifier(_)), operator: FunctionArgOperator::Colon } )); assert!(matches!( args[2], FunctionArg::ExprNamed { name: Expr::Value(ValueWithSpan { value: Value::SingleQuotedString(_), span: _ }), arg: FunctionArgExpr::Expr(Expr::CompoundIdentifier(_)), operator: FunctionArgOperator::Colon } )); } _ => unreachable!(), } } #[test] fn parse_mssql_json_array() { let select = ms().verified_only_select("SELECT JSON_ARRAY('a', 1, NULL, 2 NULL ON NULL)"); match expr_from_projection(&select.projection[0]) { Expr::Function(Function { args: FunctionArguments::List(FunctionArgumentList { args, clauses, .. }), .. }) => { assert_eq!( &[ FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::Value( (Value::SingleQuotedString("a".into())).with_empty_span() ))), FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::Value( (number("1")).with_empty_span() ))), FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::Value( (Value::Null).with_empty_span() ))), FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::Value( (number("2")).with_empty_span() ))), ], &args[..] ); assert_eq!( &[FunctionArgumentClause::JsonNullClause( JsonNullClause::NullOnNull )], &clauses[..] ); } _ => unreachable!(), } let select = ms().verified_only_select("SELECT JSON_ARRAY('a', 1, NULL, 2 ABSENT ON NULL)"); match expr_from_projection(&select.projection[0]) { Expr::Function(Function { args: FunctionArguments::List(FunctionArgumentList { args, clauses, .. }), .. }) => { assert_eq!( &[ FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::Value( (Value::SingleQuotedString("a".into())).with_empty_span() ))), FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::Value( (number("1")).with_empty_span() ))), FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::Value( (Value::Null).with_empty_span() ))), FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::Value( (number("2")).with_empty_span() ))), ], &args[..] ); assert_eq!( &[FunctionArgumentClause::JsonNullClause( JsonNullClause::AbsentOnNull )], &clauses[..] ); } _ => unreachable!(), } let select = ms().verified_only_select("SELECT JSON_ARRAY(NULL ON NULL)"); match expr_from_projection(&select.projection[0]) { Expr::Function(Function { args: FunctionArguments::List(FunctionArgumentList { args, clauses, .. }), .. }) => { assert!(args.is_empty()); assert_eq!( &[FunctionArgumentClause::JsonNullClause( JsonNullClause::NullOnNull )], &clauses[..] ); } _ => unreachable!(), } let select = ms().verified_only_select("SELECT JSON_ARRAY(ABSENT ON NULL)"); match expr_from_projection(&select.projection[0]) { Expr::Function(Function { args: FunctionArguments::List(FunctionArgumentList { args, clauses, .. }), .. }) => { assert!(args.is_empty()); assert_eq!( &[FunctionArgumentClause::JsonNullClause( JsonNullClause::AbsentOnNull )], &clauses[..] ); } _ => unreachable!(), } let select = ms().verified_only_select( "SELECT JSON_ARRAY('a', JSON_OBJECT('name' : 'value', 'type' : 1) NULL ON NULL)", ); match expr_from_projection(&select.projection[0]) { Expr::Function(Function { args: FunctionArguments::List(FunctionArgumentList { args, clauses, .. }), .. }) => { assert_eq!( &FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::Value( (Value::SingleQuotedString("a".into())).with_empty_span() ))), &args[0] ); assert!(matches!( args[1], FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::Function(_))) )); assert_eq!( &[FunctionArgumentClause::JsonNullClause( JsonNullClause::NullOnNull )], &clauses[..] ); } _ => unreachable!(), } let select = ms().verified_only_select( "SELECT JSON_ARRAY('a', JSON_OBJECT('name' : 'value', 'type' : 1), JSON_ARRAY(1, NULL, 2 NULL ON NULL))", ); match expr_from_projection(&select.projection[0]) { Expr::Function(Function { args: FunctionArguments::List(FunctionArgumentList { args, .. }), .. }) => { assert_eq!( &FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::Value( (Value::SingleQuotedString("a".into())).with_empty_span() ))), &args[0] ); assert!(matches!( args[1], FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::Function(_))) )); assert!(matches!( args[2], FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::Function(_))) )); } _ => unreachable!(), } let select = ms().verified_only_select("SELECT JSON_ARRAY(1, @id_value, (SELECT @@SPID))"); match expr_from_projection(&select.projection[0]) { Expr::Function(Function { args: FunctionArguments::List(FunctionArgumentList { args, .. }), .. }) => { assert_eq!( &FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::Value( (number("1")).with_empty_span() ))), &args[0] ); assert!(matches!( args[1], FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::Identifier(_))) )); assert!(matches!( args[2], FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::Subquery(_))) )); } _ => unreachable!(), } let select = ms().verified_only_select( "SELECT s.session_id, JSON_ARRAY(s.host_name, s.program_name, s.client_interface_name NULL ON NULL) AS info \ FROM sys.dm_exec_sessions AS s \ WHERE s.is_user_process = 1", ); match &select.projection[1] { SelectItem::ExprWithAlias { expr: Expr::Function(Function { args: FunctionArguments::List(FunctionArgumentList { args, clauses, .. }), .. }), .. } => { assert!(matches!( args[0], FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::CompoundIdentifier(_))) )); assert!(matches!( args[1], FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::CompoundIdentifier(_))) )); assert!(matches!( args[2], FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::CompoundIdentifier(_))) )); assert_eq!( &[FunctionArgumentClause::JsonNullClause( JsonNullClause::NullOnNull )], &clauses[..] ); } _ => unreachable!(), } } #[test] fn parse_ampersand_arobase() { // In SQL Server, a&@b means (a) & (@b), in PostgreSQL it means (a) &@ (b) ms().expr_parses_to("a&@b", "a & @b"); } #[test] fn parse_cast_varchar_max() { ms_and_generic().verified_expr("CAST('foo' AS VARCHAR(MAX))"); ms_and_generic().verified_expr("CAST('foo' AS NVARCHAR(MAX))"); } #[test] fn parse_convert() { let sql = "CONVERT(INT, 1, 2, 3, NULL)"; let Expr::Convert { is_try, expr, data_type, charset, target_before_value, styles, } = ms().verified_expr(sql) else { unreachable!() }; assert!(!is_try); assert_eq!(Expr::value(number("1")), *expr); assert_eq!(Some(DataType::Int(None)), data_type); assert!(charset.is_none()); assert!(target_before_value); assert_eq!( vec![ Expr::value(number("2")), Expr::value(number("3")), Expr::Value((Value::Null).with_empty_span()), ], styles ); ms().verified_expr("CONVERT(VARCHAR(MAX), 'foo')"); ms().verified_expr("CONVERT(VARCHAR(10), 'foo')"); ms().verified_expr("CONVERT(DECIMAL(10,5), 12.55)"); let error_sql = "SELECT CONVERT(INT, 'foo',) FROM T"; assert_eq!( ParserError::ParserError("Expected: an expression, found: )".to_owned()), ms().parse_sql_statements(error_sql).unwrap_err() ); } #[test] fn parse_substring_in_select() { let sql = "SELECT DISTINCT SUBSTRING(description, 0, 1) FROM test"; match ms().one_statement_parses_to( sql, "SELECT DISTINCT SUBSTRING(description, 0, 1) FROM test", ) { Statement::Query(query) => { assert_eq!( Box::new(Query { with: None, body: Box::new(SetExpr::Select(Box::new(Select { select_token: AttachedToken::empty(), optimizer_hints: vec![], distinct: Some(Distinct::Distinct), select_modifiers: None, top: None, top_before_distinct: false, projection: vec![SelectItem::UnnamedExpr(Expr::Substring { expr: Box::new(Expr::Identifier(Ident { value: "description".to_string(), quote_style: None, span: Span::empty(), })), substring_from: Some(Box::new(Expr::Value( (number("0")).with_empty_span() ))), substring_for: Some(Box::new(Expr::Value( (number("1")).with_empty_span() ))), special: true, shorthand: false, })], exclude: None, into: None, from: vec![TableWithJoins { relation: table_from_name(ObjectName::from(vec![Ident { value: "test".to_string(), quote_style: None, span: Span::empty(), }])), joins: vec![] }], lateral_views: vec![], prewhere: None, selection: None, group_by: GroupByExpr::Expressions(vec![], vec![]), cluster_by: vec![], distribute_by: vec![], sort_by: vec![], having: None, named_window: vec![], qualify: None, window_before_qualify: false, value_table_mode: None, connect_by: vec![], flavor: SelectFlavor::Standard, }))), order_by: None, limit_clause: None, fetch: None, locks: vec![], for_clause: None, settings: None, format_clause: None, pipe_operators: vec![], }), query ); } _ => unreachable!(), } } #[test] fn parse_mssql_declare() { let sql = "DECLARE @foo CURSOR, @bar INT, @baz AS TEXT = 'foobar';"; let ast = ms().parse_sql_statements(sql).unwrap(); assert_eq!( vec![Statement::Declare { stmts: vec![ Declare { names: vec![Ident { value: "@foo".to_string(), quote_style: None, span: Span::empty(), }], data_type: None, assignment: None, declare_type: Some(DeclareType::Cursor), binary: None, sensitive: None, scroll: None, hold: None, for_query: None }, Declare { names: vec![Ident { value: "@bar".to_string(), quote_style: None, span: Span::empty(), }], data_type: Some(Int(None)), assignment: None, declare_type: None, binary: None, sensitive: None, scroll: None, hold: None, for_query: None }, Declare { names: vec![Ident { value: "@baz".to_string(), quote_style: None, span: Span::empty(), }], data_type: Some(Text), assignment: Some(MsSqlAssignment(Box::new(Expr::Value( (SingleQuotedString("foobar".to_string())).with_empty_span() )))), declare_type: None, binary: None, sensitive: None, scroll: None, hold: None, for_query: None } ] }], ast ); let sql = "DECLARE @bar INT;SET @bar = 2;SELECT @bar * 4"; let ast = ms().parse_sql_statements(sql).unwrap(); assert_eq!( vec![ Statement::Declare { stmts: vec![Declare { names: vec![Ident::new("@bar"),], data_type: Some(Int(None)), assignment: None, declare_type: None, binary: None, sensitive: None, scroll: None, hold: None, for_query: None }] }, Statement::Set(Set::SingleAssignment { scope: None, hivevar: false, variable: ObjectName::from(vec![Ident::new("@bar")]), values: vec![Expr::Value( (Value::Number("2".parse().unwrap(), false)).with_empty_span() )], }), Statement::Query(Box::new(Query { with: None, limit_clause: None, fetch: None, locks: vec![], for_clause: None, order_by: None, settings: None, format_clause: None, pipe_operators: vec![], body: Box::new(SetExpr::Select(Box::new(Select { select_token: AttachedToken::empty(), optimizer_hints: vec![], distinct: None, select_modifiers: None, top: None, top_before_distinct: false, projection: vec![SelectItem::UnnamedExpr(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("@bar"))), op: BinaryOperator::Multiply, right: Box::new(Expr::Value( (Value::Number("4".parse().unwrap(), false)).with_empty_span() )), })], exclude: None, into: None, from: vec![], lateral_views: vec![], prewhere: None, selection: None, group_by: GroupByExpr::Expressions(vec![], vec![]), cluster_by: vec![], distribute_by: vec![], sort_by: vec![], having: None, named_window: vec![], window_before_qualify: false, qualify: None, value_table_mode: None, connect_by: vec![], flavor: SelectFlavor::Standard, }))) })) ], ast ); let declare_cursor_for_select = "DECLARE vend_cursor CURSOR FOR SELECT * FROM Purchasing.Vendor"; let _ = ms().verified_stmt(declare_cursor_for_select); } #[test] fn test_mssql_cursor() { let full_cursor_usage = "\ DECLARE Employee_Cursor CURSOR FOR \ SELECT LastName, FirstName \ FROM AdventureWorks2022.HumanResources.vEmployee \ WHERE LastName LIKE 'B%'; \ \ OPEN Employee_Cursor; \ \ FETCH NEXT FROM Employee_Cursor; \ \ WHILE @@FETCH_STATUS = 0 \ BEGIN \ FETCH NEXT FROM Employee_Cursor; \ END; \ \ CLOSE Employee_Cursor; \ DEALLOCATE Employee_Cursor\ "; let _ = ms().statements_parse_to(full_cursor_usage, ""); } #[test] fn test_mssql_while_statement() { let while_single_statement = "WHILE 1 = 0 PRINT 'Hello World';"; let stmt = ms().verified_stmt(while_single_statement); assert_eq!( stmt, Statement::While(sqlparser::ast::WhileStatement { while_block: ConditionalStatementBlock { start_token: AttachedToken(TokenWithSpan { token: Token::Word(Word { value: "WHILE".to_string(), quote_style: None, keyword: Keyword::WHILE }), span: Span::empty() }), condition: Some(Expr::BinaryOp { left: Box::new(Expr::Value( (Value::Number("1".parse().unwrap(), false)).with_empty_span() )), op: BinaryOperator::Eq, right: Box::new(Expr::Value( (Value::Number("0".parse().unwrap(), false)).with_empty_span() )), }), then_token: None, conditional_statements: ConditionalStatements::Sequence { statements: vec![Statement::Print(PrintStatement { message: Box::new(Expr::Value( (Value::SingleQuotedString("Hello World".to_string())) .with_empty_span() )), })], } } }) ); let while_begin_end = "\ WHILE @@FETCH_STATUS = 0 \ BEGIN \ FETCH NEXT FROM Employee_Cursor; \ END\ "; let _ = ms().verified_stmt(while_begin_end); let while_begin_end_multiple_statements = "\ WHILE @@FETCH_STATUS = 0 \ BEGIN \ FETCH NEXT FROM Employee_Cursor; \ PRINT 'Hello World'; \ END\ "; let _ = ms().verified_stmt(while_begin_end_multiple_statements); } #[test] fn test_parse_raiserror() { let sql = r#"RAISERROR('This is a test', 16, 1)"#; let s = ms().verified_stmt(sql); assert_eq!( s, Statement::RaisError { message: Box::new(Expr::Value( (Value::SingleQuotedString("This is a test".to_string())).with_empty_span() )), severity: Box::new(Expr::Value( (Value::Number("16".parse().unwrap(), false)).with_empty_span() )), state: Box::new(Expr::Value( (Value::Number("1".parse().unwrap(), false)).with_empty_span() )), arguments: vec![], options: vec![], } ); let sql = r#"RAISERROR('This is a test', 16, 1) WITH NOWAIT"#; let _ = ms().verified_stmt(sql); let sql = r#"RAISERROR('This is a test', 16, 1, 'ARG') WITH SETERROR, LOG"#; let _ = ms().verified_stmt(sql); let sql = r#"RAISERROR(N'This is message %s %d.', 10, 1, N'number', 5)"#; let _ = ms().verified_stmt(sql); let sql = r#"RAISERROR(N'<<%*.*s>>', 10, 1, 7, 3, N'abcde')"#; let _ = ms().verified_stmt(sql); let sql = r#"RAISERROR(@ErrorMessage, @ErrorSeverity, @ErrorState)"#; let _ = ms().verified_stmt(sql); } #[test] fn test_parse_throw() { // THROW with arguments let sql = r#"THROW 51000, 'Record does not exist.', 1"#; let s = ms().verified_stmt(sql); assert_eq!( s, Statement::Throw(ThrowStatement { error_number: Some(Box::new(Expr::Value( (Value::Number("51000".parse().unwrap(), false)).with_empty_span() ))), message: Some(Box::new(Expr::Value( (Value::SingleQuotedString("Record does not exist.".to_string())).with_empty_span() ))), state: Some(Box::new(Expr::Value( (Value::Number("1".parse().unwrap(), false)).with_empty_span() ))), }) ); // THROW with variable references let sql = r#"THROW @ErrorNumber, @ErrorMessage, @ErrorState"#; let _ = ms().verified_stmt(sql); // Re-throw (no arguments) let sql = r#"THROW"#; let s = ms().verified_stmt(sql); assert_eq!( s, Statement::Throw(ThrowStatement { error_number: None, message: None, state: None, }) ); } #[test] fn test_parse_waitfor() { // WAITFOR DELAY let sql = "WAITFOR DELAY '00:00:05'"; let stmt = ms_and_generic().verified_stmt(sql); assert_eq!( stmt, Statement::WaitFor(WaitForStatement { wait_type: WaitForType::Delay, expr: Expr::Value( (Value::SingleQuotedString("00:00:05".to_string())).with_empty_span() ), }) ); // WAITFOR TIME let sql = "WAITFOR TIME '14:30:00'"; let stmt = ms_and_generic().verified_stmt(sql); assert_eq!( stmt, Statement::WaitFor(WaitForStatement { wait_type: WaitForType::Time, expr: Expr::Value( (Value::SingleQuotedString("14:30:00".to_string())).with_empty_span() ), }) ); // WAITFOR DELAY with variable let sql = "WAITFOR DELAY @WaitTime"; let _ = ms_and_generic().verified_stmt(sql); // Error: WAITFOR without DELAY or TIME let res = ms_and_generic().parse_sql_statements("WAITFOR '00:00:05'"); assert!(res.is_err()); } #[test] fn parse_use() { let valid_object_names = [ "mydb", "SCHEMA", "DATABASE", "CATALOG", "WAREHOUSE", "DEFAULT", ]; let quote_styles = ['\'', '"']; for object_name in &valid_object_names { // Test single identifier without quotes assert_eq!( ms().verified_stmt(&format!("USE {object_name}")), Statement::Use(Use::Object(ObjectName::from(vec![Ident::new( object_name.to_string() )]))) ); for "e in "e_styles { // Test single identifier with different type of quotes assert_eq!( ms().verified_stmt(&format!("USE {quote}{object_name}{quote}")), Statement::Use(Use::Object(ObjectName::from(vec![Ident::with_quote( quote, object_name.to_string(), )]))) ); } } } #[test] fn parse_create_table_with_valid_options() { let options = [ ( "CREATE TABLE mytable (column_a INT, column_b INT, column_c INT) WITH (DISTRIBUTION = ROUND_ROBIN, PARTITION (column_a RANGE FOR VALUES (10, 11)))", vec![ SqlOption::KeyValue { key: Ident { value: "DISTRIBUTION".to_string(), quote_style: None, span: Span::empty(), }, value: Expr::Identifier(Ident { value: "ROUND_ROBIN".to_string(), quote_style: None, span: Span::empty(), }) }, SqlOption::Partition { column_name: "column_a".into(), range_direction: None, for_values: vec![Expr::Value((test_utils::number("10")).with_empty_span()), Expr::Value((test_utils::number("11")).with_empty_span())] , }, ], ), ( "CREATE TABLE mytable (column_a INT, column_b INT, column_c INT) WITH (PARTITION (column_a RANGE LEFT FOR VALUES (10, 11)))", vec![ SqlOption::Partition { column_name: "column_a".into(), range_direction: Some(PartitionRangeDirection::Left), for_values: vec![ Expr::Value((test_utils::number("10")).with_empty_span()), Expr::Value((test_utils::number("11")).with_empty_span()), ], } ], ), ( "CREATE TABLE mytable (column_a INT, column_b INT, column_c INT) WITH (CLUSTERED COLUMNSTORE INDEX)", vec![SqlOption::Clustered(TableOptionsClustered::ColumnstoreIndex)], ), ( "CREATE TABLE mytable (column_a INT, column_b INT, column_c INT) WITH (CLUSTERED COLUMNSTORE INDEX ORDER (column_a, column_b))", vec![ SqlOption::Clustered(TableOptionsClustered::ColumnstoreIndexOrder(vec![ "column_a".into(), "column_b".into(), ])) ], ), ( "CREATE TABLE mytable (column_a INT, column_b INT, column_c INT) WITH (CLUSTERED INDEX (column_a ASC, column_b DESC, column_c))", vec![ SqlOption::Clustered(TableOptionsClustered::Index(vec![ ClusteredIndex { name: Ident { value: "column_a".to_string(), quote_style: None, span: Span::empty(), }, asc: Some(true), }, ClusteredIndex { name: Ident { value: "column_b".to_string(), quote_style: None, span: Span::empty(), }, asc: Some(false), }, ClusteredIndex { name: Ident { value: "column_c".to_string(), quote_style: None, span: Span::empty(), }, asc: None, }, ])) ], ), ( "CREATE TABLE mytable (column_a INT, column_b INT, column_c INT) WITH (DISTRIBUTION = HASH(column_a, column_b), HEAP)", vec![ SqlOption::KeyValue { key: Ident { value: "DISTRIBUTION".to_string(), quote_style: None, span: Span::empty(), }, value: Expr::Function( Function { name: ObjectName::from( vec![ Ident { value: "HASH".to_string(), quote_style: None, span: Span::empty(), }, ], ), uses_odbc_syntax: false, parameters: FunctionArguments::None, args: FunctionArguments::List( FunctionArgumentList { duplicate_treatment: None, args: vec![ FunctionArg::Unnamed( FunctionArgExpr::Expr( Expr::Identifier( Ident { value: "column_a".to_string(), quote_style: None, span: Span::empty(), }, ), ), ), FunctionArg::Unnamed( FunctionArgExpr::Expr( Expr::Identifier( Ident { value: "column_b".to_string(), quote_style: None, span: Span::empty(), }, ), ), ), ], clauses: vec![], }, ), filter: None, null_treatment: None, over: None, within_group: vec![], }, ), }, SqlOption::Ident("HEAP".into()), ], ), ]; for (sql, with_options) in options { assert_eq!( ms_and_generic().verified_stmt(sql), Statement::CreateTable(CreateTable { or_replace: false, temporary: false, external: false, global: None, dynamic: false, if_not_exists: false, transient: false, volatile: false, name: ObjectName::from(vec![Ident { value: "mytable".to_string(), quote_style: None, span: Span::empty(), },],), columns: vec![ ColumnDef { name: Ident { value: "column_a".to_string(), quote_style: None, span: Span::empty(), }, data_type: Int(None,), options: vec![], }, ColumnDef { name: Ident { value: "column_b".to_string(), quote_style: None, span: Span::empty(), }, data_type: Int(None,), options: vec![], }, ColumnDef { name: Ident { value: "column_c".to_string(), quote_style: None, span: Span::empty(), }, data_type: Int(None,), options: vec![], }, ], constraints: vec![], hive_distribution: HiveDistributionStyle::NONE, hive_formats: None, file_format: None, location: None, query: None, without_rowid: false, like: None, clone: None, comment: None, on_commit: None, on_cluster: None, primary_key: None, order_by: None, partition_by: None, cluster_by: None, clustered_by: None, inherits: None, partition_of: None, for_values: None, strict: false, iceberg: false, snapshot: false, copy_grants: false, enable_schema_evolution: None, change_tracking: None, data_retention_time_in_days: None, max_data_extension_time_in_days: None, default_ddl_collation: None, with_aggregation_policy: None, with_row_access_policy: None, with_storage_lifecycle_policy: None, with_tags: None, base_location: None, external_volume: None, catalog: None, catalog_sync: None, storage_serialization_policy: None, table_options: CreateTableOptions::With(with_options), target_lag: None, warehouse: None, version: None, refresh_mode: None, initialize: None, require_user: false, diststyle: None, distkey: None, sortkey: None, backup: None, }) ); } } #[test] fn parse_nested_slash_star_comment() { let sql = r#" select /* comment level 1 /* comment level 2 */ */ 1; "#; let canonical = "SELECT 1"; ms().one_statement_parses_to(sql, canonical); } #[test] fn parse_create_table_with_invalid_options() { let invalid_cases = vec![ ( "CREATE TABLE mytable (column_a INT, column_b INT, column_c INT) WITH (CLUSTERED COLUMNSTORE INDEX ORDER ())", "Expected: identifier, found: )", ), ( "CREATE TABLE mytable (column_a INT, column_b INT, column_c INT) WITH (CLUSTERED COLUMNSTORE)", "invalid CLUSTERED sequence", ), ( "CREATE TABLE mytable (column_a INT, column_b INT, column_c INT) WITH (HEAP INDEX)", "Expected: ), found: INDEX", ), ( "CREATE TABLE mytable (column_a INT, column_b INT, column_c INT) WITH (PARTITION (RANGE LEFT FOR VALUES (10, 11)))", "Expected: RANGE, found: LEFT", ), ]; for (sql, expected_error) in invalid_cases { let res = ms_and_generic().parse_sql_statements(sql); assert_eq!( format!("sql parser error: {expected_error}"), res.unwrap_err().to_string() ); } } #[test] fn parse_create_table_with_identity_column() { let with_column_options = [ ( r#"CREATE TABLE mytable (columnA INT IDENTITY NOT NULL)"#, vec![ ColumnOptionDef { name: None, option: ColumnOption::Identity(IdentityPropertyKind::Identity( IdentityProperty { parameters: None, order: None, }, )), }, ColumnOptionDef { name: None, option: ColumnOption::NotNull, }, ], ), ( r#"CREATE TABLE mytable (columnA INT IDENTITY(1, 1) NOT NULL)"#, vec![ ColumnOptionDef { name: None, option: ColumnOption::Identity(IdentityPropertyKind::Identity( IdentityProperty { parameters: Some(IdentityPropertyFormatKind::FunctionCall( IdentityParameters { seed: Expr::value(number("1")), increment: Expr::value(number("1")), }, )), order: None, }, )), }, ColumnOptionDef { name: None, option: ColumnOption::NotNull, }, ], ), ]; for (sql, column_options) in with_column_options { assert_eq!( ms_and_generic().verified_stmt(sql), Statement::CreateTable(CreateTable { or_replace: false, temporary: false, external: false, global: None, dynamic: false, if_not_exists: false, transient: false, volatile: false, iceberg: false, snapshot: false, name: ObjectName::from(vec![Ident { value: "mytable".to_string(), quote_style: None, span: Span::empty(), },],), columns: vec![ColumnDef { name: Ident { value: "columnA".to_string(), quote_style: None, span: Span::empty(), }, data_type: Int(None,), options: column_options, },], constraints: vec![], hive_distribution: HiveDistributionStyle::NONE, hive_formats: None, file_format: None, location: None, query: None, without_rowid: false, like: None, clone: None, comment: None, on_commit: None, on_cluster: None, primary_key: None, order_by: None, partition_by: None, cluster_by: None, clustered_by: None, inherits: None, partition_of: None, for_values: None, strict: false, copy_grants: false, enable_schema_evolution: None, change_tracking: None, data_retention_time_in_days: None, max_data_extension_time_in_days: None, default_ddl_collation: None, with_aggregation_policy: None, with_row_access_policy: None, with_storage_lifecycle_policy: None, with_tags: None, base_location: None, external_volume: None, catalog: None, catalog_sync: None, storage_serialization_policy: None, table_options: CreateTableOptions::None, target_lag: None, warehouse: None, version: None, refresh_mode: None, initialize: None, require_user: false, diststyle: None, distkey: None, sortkey: None, backup: None, }), ); } } #[test] fn parse_true_false_as_identifiers() { assert_eq!( ms().verified_expr("true"), Expr::Identifier(Ident::new("true")) ); assert_eq!( ms().verified_expr("false"), Expr::Identifier(Ident::new("false")) ); } #[test] fn parse_mssql_set_session_value() { ms().verified_stmt( "SET OFFSETS SELECT, FROM, ORDER, TABLE, PROCEDURE, STATEMENT, PARAM, EXECUTE ON", ); ms().verified_stmt("SET IDENTITY_INSERT dbo.Tool ON"); ms().verified_stmt("SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED"); ms().verified_stmt("SET TRANSACTION ISOLATION LEVEL READ COMMITTED"); ms().verified_stmt("SET TRANSACTION ISOLATION LEVEL REPEATABLE READ"); ms().verified_stmt("SET TRANSACTION ISOLATION LEVEL SNAPSHOT"); ms().verified_stmt("SET TRANSACTION ISOLATION LEVEL SERIALIZABLE"); ms().verified_stmt("SET STATISTICS IO ON"); ms().verified_stmt("SET STATISTICS XML ON"); ms().verified_stmt("SET STATISTICS PROFILE ON"); ms().verified_stmt("SET STATISTICS TIME ON"); ms().verified_stmt("SET DATEFIRST 7"); ms().verified_stmt("SET DATEFIRST @xxx"); ms().verified_stmt("SET DATEFIRST @@xxx"); ms().verified_stmt("SET DATEFORMAT dmy"); ms().verified_stmt("SET DATEFORMAT @datevar"); ms().verified_stmt("SET DATEFORMAT @@datevar"); ms().verified_stmt("SET DEADLOCK_PRIORITY 'LOW'"); ms().verified_stmt("SET DEADLOCK_PRIORITY LOW"); ms().verified_stmt("SET DEADLOCK_PRIORITY 8"); ms().verified_stmt("SET DEADLOCK_PRIORITY -8"); ms().verified_stmt("SET DEADLOCK_PRIORITY @xxx"); ms().verified_stmt("SET DEADLOCK_PRIORITY @@xxx"); ms().verified_stmt("SET LOCK_TIMEOUT 1800"); ms().verified_stmt("SET CONCAT_NULL_YIELDS_NULL ON"); ms().verified_stmt("SET CURSOR_CLOSE_ON_COMMIT ON"); ms().verified_stmt("SET FIPS_FLAGGER 'level'"); ms().verified_stmt("SET FIPS_FLAGGER OFF"); ms().verified_stmt("SET LANGUAGE Italian"); ms().verified_stmt("SET QUOTED_IDENTIFIER ON"); ms().verified_stmt("SET ARITHABORT ON"); ms().verified_stmt("SET ARITHIGNORE OFF"); ms().verified_stmt("SET FMTONLY ON"); ms().verified_stmt("SET NOCOUNT OFF"); ms().verified_stmt("SET NOEXEC ON"); ms().verified_stmt("SET NUMERIC_ROUNDABORT ON"); ms().verified_stmt("SET QUERY_GOVERNOR_COST_LIMIT 11"); ms().verified_stmt("SET ROWCOUNT 4"); ms().verified_stmt("SET ROWCOUNT @xxx"); ms().verified_stmt("SET ROWCOUNT @@xxx"); ms().verified_stmt("SET TEXTSIZE 11"); ms().verified_stmt("SET ANSI_DEFAULTS ON"); ms().verified_stmt("SET ANSI_NULL_DFLT_OFF ON"); ms().verified_stmt("SET ANSI_NULL_DFLT_ON ON"); ms().verified_stmt("SET ANSI_NULLS ON"); ms().verified_stmt("SET ANSI_PADDING ON"); ms().verified_stmt("SET ANSI_WARNINGS ON"); ms().verified_stmt("SET FORCEPLAN ON"); ms().verified_stmt("SET SHOWPLAN_ALL ON"); ms().verified_stmt("SET SHOWPLAN_TEXT ON"); ms().verified_stmt("SET SHOWPLAN_XML ON"); ms().verified_stmt("SET IMPLICIT_TRANSACTIONS ON"); ms().verified_stmt("SET REMOTE_PROC_TRANSACTIONS ON"); ms().verified_stmt("SET XACT_ABORT ON"); ms().verified_stmt("SET ANSI_NULLS, ANSI_PADDING ON"); } #[test] fn parse_mssql_if_else() { // Simple statements and blocks ms().verified_stmt("IF 1 = 1 SELECT '1'; ELSE SELECT '2';"); ms().verified_stmt("IF 1 = 1 BEGIN SET @A = 1; END ELSE SET @A = 2;"); ms().verified_stmt( "IF DATENAME(weekday, GETDATE()) IN (N'Saturday', N'Sunday') SELECT 'Weekend'; ELSE SELECT 'Weekday';" ); ms().verified_stmt( "IF (SELECT COUNT(*) FROM a.b WHERE c LIKE 'x%') > 1 SELECT 'yes'; ELSE SELECT 'No';", ); // Multiple statements let stmts = ms() .parse_sql_statements("DECLARE @A INT; IF 1=1 BEGIN SET @A = 1 END ELSE SET @A = 2") .unwrap(); match &stmts[..] { [Statement::Declare { .. }, Statement::If(stmt)] => { assert_eq!( stmt.to_string(), "IF 1 = 1 BEGIN SET @A = 1; END ELSE SET @A = 2;" ); } _ => panic!("Unexpected statements: {stmts:?}"), } } #[test] fn test_mssql_if_else_span() { let sql = "IF 1 = 1 SELECT '1' ELSE SELECT '2'"; let mut parser = Parser::new(&MsSqlDialect {}).try_with_sql(sql).unwrap(); assert_eq!( parser.parse_statement().unwrap().span(), Span::new(Location::new(1, 1), Location::new(1, sql.len() as u64 + 1)) ); } #[test] fn test_mssql_if_else_multiline_span() { let sql_line1 = "IF 1 = 1"; let sql_line2 = "SELECT '1'"; let sql_line3 = "ELSE SELECT '2'"; let sql = [sql_line1, sql_line2, sql_line3].join("\n"); let mut parser = Parser::new(&MsSqlDialect {}).try_with_sql(&sql).unwrap(); assert_eq!( parser.parse_statement().unwrap().span(), Span::new( Location::new(1, 1), Location::new(3, sql_line3.len() as u64 + 1) ) ); } #[test] fn test_mssql_if_statements_span() { // Simple statements let mut sql = "IF 1 = 1 SELECT '1' ELSE SELECT '2'"; let mut parser = Parser::new(&MsSqlDialect {}).try_with_sql(sql).unwrap(); match parser.parse_statement().unwrap() { Statement::If(IfStatement { if_block, else_block: Some(else_block), .. }) => { assert_eq!( if_block.span(), Span::new(Location::new(1, 1), Location::new(1, 20)) ); assert_eq!( else_block.span(), Span::new(Location::new(1, 21), Location::new(1, 36)) ); } stmt => panic!("Unexpected statement: {stmt:?}"), } // Blocks sql = "IF 1 = 1 BEGIN SET @A = 1; END ELSE BEGIN SET @A = 2 END"; parser = Parser::new(&MsSqlDialect {}).try_with_sql(sql).unwrap(); match parser.parse_statement().unwrap() { Statement::If(IfStatement { if_block, else_block: Some(else_block), .. }) => { assert_eq!( if_block.span(), Span::new(Location::new(1, 1), Location::new(1, 31)) ); assert_eq!( else_block.span(), Span::new(Location::new(1, 32), Location::new(1, 57)) ); } stmt => panic!("Unexpected statement: {stmt:?}"), } } #[test] fn parse_mssql_varbinary_max_length() { let sql = "CREATE TABLE example (var_binary_col VARBINARY(MAX))"; match ms_and_generic().verified_stmt(sql) { Statement::CreateTable(CreateTable { name, columns, .. }) => { assert_eq!( name, ObjectName::from(vec![Ident { value: "example".to_string(), quote_style: None, span: Span::empty(), }]) ); assert_eq!( columns, vec![ColumnDef { name: Ident::new("var_binary_col"), data_type: Varbinary(Some(BinaryLength::Max)), options: vec![] },], ); } _ => unreachable!(), } let sql = "CREATE TABLE example (var_binary_col VARBINARY(50))"; match ms_and_generic().verified_stmt(sql) { Statement::CreateTable(CreateTable { name, columns, .. }) => { assert_eq!( name, ObjectName::from(vec![Ident { value: "example".to_string(), quote_style: None, span: Span::empty(), }]) ); assert_eq!( columns, vec![ColumnDef { name: Ident::new("var_binary_col"), data_type: Varbinary(Some(BinaryLength::IntegerLength { length: 50 })), options: vec![] },], ); } _ => unreachable!(), } } #[test] fn parse_mssql_table_identifier_with_default_schema() { ms().verified_stmt("SELECT * FROM mydatabase..MyTable"); } fn ms() -> TestedDialects { TestedDialects::new(vec![Box::new(MsSqlDialect {})]) } // MS SQL dialect with support for optional semi-colon statement delimiters fn tsql() -> TestedDialects { TestedDialects::new_with_options( vec![Box::new(MsSqlDialect {})], ParserOptions { trailing_commas: false, unescape: true, require_semicolon_stmt_delimiter: false, }, ) } fn ms_and_generic() -> TestedDialects { TestedDialects::new(vec![Box::new(MsSqlDialect {}), Box::new(GenericDialect {})]) } #[test] fn parse_mssql_merge_with_output() { let stmt = "MERGE dso.products AS t \ USING dsi.products AS \ s ON s.ProductID = t.ProductID \ WHEN MATCHED AND \ NOT (t.ProductName = s.ProductName OR (ISNULL(t.ProductName, s.ProductName) IS NULL)) \ THEN UPDATE SET t.ProductName = s.ProductName \ WHEN NOT MATCHED BY TARGET \ THEN INSERT (ProductID, ProductName) \ VALUES (s.ProductID, s.ProductName) \ WHEN NOT MATCHED BY SOURCE THEN DELETE \ OUTPUT $action, deleted.ProductID INTO dsi.temp_products"; ms_and_generic().verified_stmt(stmt); } #[test] fn parse_create_trigger() { let create_trigger = "\ CREATE OR ALTER TRIGGER reminder1 \ ON Sales.Customer \ AFTER INSERT, UPDATE \ AS RAISERROR('Notify Customer Relations', 16, 10);\ "; let create_stmt = ms().verified_stmt(create_trigger); assert_eq!( create_stmt, Statement::CreateTrigger(CreateTrigger { or_alter: true, temporary: false, or_replace: false, is_constraint: false, name: ObjectName::from(vec![Ident::new("reminder1")]), period: Some(TriggerPeriod::After), period_before_table: false, events: vec![TriggerEvent::Insert, TriggerEvent::Update(vec![]),], table_name: ObjectName::from(vec![Ident::new("Sales"), Ident::new("Customer")]), referenced_table_name: None, referencing: vec![], trigger_object: None, condition: None, exec_body: None, statements_as: true, statements: Some(ConditionalStatements::Sequence { statements: vec![Statement::RaisError { message: Box::new(Expr::Value( (Value::SingleQuotedString("Notify Customer Relations".to_string())) .with_empty_span() )), severity: Box::new(Expr::Value( (Value::Number("16".parse().unwrap(), false)).with_empty_span() )), state: Box::new(Expr::Value( (Value::Number("10".parse().unwrap(), false)).with_empty_span() )), arguments: vec![], options: vec![], }], }), characteristics: None, }) ); let multi_statement_as_trigger = "\ CREATE TRIGGER some_trigger ON some_table FOR INSERT \ AS \ DECLARE @var INT; \ RAISERROR('Trigger fired', 10, 1);\ "; let _ = ms().verified_stmt(multi_statement_as_trigger); let multi_statement_trigger = "\ CREATE TRIGGER some_trigger ON some_table FOR INSERT \ AS \ BEGIN \ DECLARE @var INT; \ RAISERROR('Trigger fired', 10, 1); \ END\ "; let _ = ms().verified_stmt(multi_statement_trigger); let create_trigger_with_return = "\ CREATE TRIGGER some_trigger ON some_table FOR INSERT \ AS \ BEGIN \ RETURN; \ END\ "; let _ = ms().verified_stmt(create_trigger_with_return); let create_trigger_with_return = "\ CREATE TRIGGER some_trigger ON some_table FOR INSERT \ AS \ BEGIN \ RETURN; \ END\ "; let _ = ms().verified_stmt(create_trigger_with_return); let create_trigger_with_conditional = "\ CREATE TRIGGER some_trigger ON some_table FOR INSERT \ AS \ BEGIN \ IF 1 = 2 \ BEGIN \ RAISERROR('Trigger fired', 10, 1); \ END; \ RETURN; \ END\ "; let _ = ms().verified_stmt(create_trigger_with_conditional); } #[test] fn parse_drop_trigger() { let sql_drop_trigger = "DROP TRIGGER emp_stamp;"; let drop_stmt = ms().one_statement_parses_to(sql_drop_trigger, ""); assert_eq!( drop_stmt, Statement::DropTrigger(DropTrigger { if_exists: false, trigger_name: ObjectName::from(vec![Ident::new("emp_stamp")]), table_name: None, option: None, }) ); } #[test] fn parse_print() { let print_string_literal = "PRINT 'Hello, world!'"; let print_stmt = ms().verified_stmt(print_string_literal); assert_eq!( print_stmt, Statement::Print(PrintStatement { message: Box::new(Expr::Value( (Value::SingleQuotedString("Hello, world!".to_string())).with_empty_span() )), }) ); let _ = ms().verified_stmt("PRINT N'Hello, ⛄️!'"); let _ = ms().verified_stmt("PRINT @my_variable"); } #[test] fn parse_mssql_grant() { ms().verified_stmt("GRANT SELECT ON my_table TO public, db_admin"); } #[test] fn parse_mssql_deny() { ms().verified_stmt("DENY SELECT ON my_table TO public, db_admin"); } #[test] fn test_tsql_no_semicolon_delimiter() { let sql = r#" DECLARE @X AS NVARCHAR(MAX)='x' DECLARE @Y AS NVARCHAR(MAX)='y' "#; let stmts = tsql().parse_sql_statements(sql).unwrap(); assert_eq!(stmts.len(), 2); assert!(stmts.iter().all(|s| matches!(s, Statement::Declare { .. }))); let sql = r#" SELECT col FROM tbl IF x=1 SELECT 1 ELSE SELECT 2 "#; let stmts = tsql().parse_sql_statements(sql).unwrap(); assert_eq!(stmts.len(), 2); assert!(matches!(&stmts[0], Statement::Query(_))); assert!(matches!(&stmts[1], Statement::If(_))); } #[test] fn test_sql_keywords_as_table_aliases() { // Some keywords that should not be parsed as an alias implicitly or explicitly let reserved_kws = vec!["IF", "ELSE"]; for kw in reserved_kws { for explicit in &["", "AS "] { assert!(tsql() .parse_sql_statements(&format!("SELECT * FROM tbl {explicit}{kw}")) .is_err()); } } } #[test] fn test_sql_keywords_as_column_aliases() { // Some keywords that should not be parsed as an alias implicitly or explicitly let reserved_kws = vec!["IF", "ELSE"]; for kw in reserved_kws { for explicit in &["", "AS "] { assert!(tsql() .parse_sql_statements(&format!("SELECT col {explicit}{kw} FROM tbl")) .is_err()); } } } #[test] fn parse_mssql_begin_end_block() { // Single statement let sql = "BEGIN SELECT 1; END"; let stmt = ms().verified_stmt(sql); match &stmt { Statement::StartTransaction { begin, has_end_keyword, statements, transaction, modifier, .. } => { assert!(begin); assert!(has_end_keyword); assert!(transaction.is_none()); assert!(modifier.is_none()); assert_eq!(statements.len(), 1); } _ => panic!("Expected StartTransaction, got: {stmt:?}"), } // Multiple statements let sql = "BEGIN SELECT 1; SELECT 2; END"; let stmt = ms().verified_stmt(sql); match &stmt { Statement::StartTransaction { statements, has_end_keyword, .. } => { assert!(has_end_keyword); assert_eq!(statements.len(), 2); } _ => panic!("Expected StartTransaction, got: {stmt:?}"), } // DML inside BEGIN/END let sql = "BEGIN INSERT INTO t VALUES (1); UPDATE t SET x = 2; END"; let stmt = ms().verified_stmt(sql); match &stmt { Statement::StartTransaction { statements, has_end_keyword, .. } => { assert!(has_end_keyword); assert_eq!(statements.len(), 2); } _ => panic!("Expected StartTransaction, got: {stmt:?}"), } // BEGIN TRANSACTION still works let sql = "BEGIN TRANSACTION"; let stmt = ms().verified_stmt(sql); match &stmt { Statement::StartTransaction { begin, has_end_keyword, transaction, .. } => { assert!(begin); assert!(!has_end_keyword); assert!(transaction.is_some()); } _ => panic!("Expected StartTransaction, got: {stmt:?}"), } } /// MSSQL supports `TRAN` as shorthand for `TRANSACTION`. /// See #[test] fn parse_mssql_tran_shorthand() { // BEGIN TRAN let sql = "BEGIN TRAN"; let stmt = ms().verified_stmt(sql); match &stmt { Statement::StartTransaction { begin, transaction, has_end_keyword, .. } => { assert!(begin); assert_eq!(*transaction, Some(BeginTransactionKind::Tran)); assert!(!has_end_keyword); } _ => panic!("Expected StartTransaction, got: {stmt:?}"), } // COMMIT TRAN normalizes to COMMIT (same as COMMIT TRANSACTION) ms().one_statement_parses_to("COMMIT TRAN", "COMMIT"); // ROLLBACK TRAN normalizes to ROLLBACK (same as ROLLBACK TRANSACTION) ms().one_statement_parses_to("ROLLBACK TRAN", "ROLLBACK"); } #[test] fn test_tsql_statement_keywords_not_implicit_aliases() { // T-SQL statement-starting keywords must never be consumed as implicit // aliases for a preceding SELECT item or table reference when using // newline-delimited multi-statement scripts. // Without the fix, the parser would consume a statement-starting keyword // as an implicit alias for the preceding SELECT item or table reference, // then fail on the next token. Verify parsing succeeds and each input // produces the expected number of statements. // Keywords that should not become implicit column aliases let col_alias_cases: &[(&str, usize)] = &[ ("select 1\ndeclare @x as int", 2), ("select 1\nexec sp_who", 2), ("select 1\ninsert into t values (1)", 2), ("select 1\nupdate t set col=1", 2), ("select 1\ndelete from t", 2), ("select 1\ndrop table t", 2), ("select 1\ncreate table t (id int)", 2), ("select 1\nalter table t add col int", 2), ("select 1\nreturn", 2), ]; for (sql, expected) in col_alias_cases { let stmts = tsql() .parse_sql_statements(sql) .unwrap_or_else(|e| panic!("failed to parse {sql:?}: {e}")); assert_eq!( stmts.len(), *expected, "expected {expected} stmts for: {sql:?}" ); } // Keywords that should not become implicit table aliases let tbl_alias_cases: &[(&str, usize)] = &[ ("select * from t\ndeclare @x as int", 2), ("select * from t\ndrop table t", 2), ("select * from t\ncreate table u (id int)", 2), ("select * from t\nexec sp_who", 2), ]; for (sql, expected) in tbl_alias_cases { let stmts = tsql() .parse_sql_statements(sql) .unwrap_or_else(|e| panic!("failed to parse {sql:?}: {e}")); assert_eq!( stmts.len(), *expected, "expected {expected} stmts for: {sql:?}" ); } } #[test] fn test_exec_dynamic_sql() { // EXEC (@sql) executes a dynamic SQL string held in a variable. // It must parse as a single Execute statement and not attempt to parse // parameters after the closing paren. let stmts = tsql() .parse_sql_statements("EXEC (@sql)") .expect("EXEC (@sql) should parse"); assert_eq!(stmts.len(), 1); assert!( matches!(&stmts[0], Statement::Execute { .. }), "expected Execute, got: {:?}", stmts[0] ); // Verify that a statement following EXEC (@sql) on the next line is parsed // as a separate statement and not consumed as a parameter. let stmts = tsql() .parse_sql_statements("EXEC (@sql)\nDROP TABLE #tmp") .expect("EXEC (@sql) followed by DROP TABLE should parse"); assert_eq!(stmts.len(), 2); } #[test] fn test_exec_dynamic_sql_string_concat() { // EXEC with string concatenation: EXEC ('...' + @var + '...') let stmts = tsql() .parse_sql_statements("EXEC ('SELECT * FROM ' + @TableName + ' WHERE 1=1')") .expect("EXEC with string concatenation should parse"); assert_eq!(stmts.len(), 1); assert!( matches!(&stmts[0], Statement::Execute { .. }), "expected Execute, got: {:?}", stmts[0] ); } // MSSQL OUTPUT clause on INSERT/UPDATE/DELETE // https://learn.microsoft.com/en-us/sql/t-sql/queries/output-clause-transact-sql #[test] fn parse_mssql_insert_with_output() { ms_and_generic().verified_stmt( "INSERT INTO customers (name, email) OUTPUT INSERTED.id, INSERTED.name VALUES ('John', 'john@example.com')", ); } #[test] fn parse_mssql_insert_with_output_into() { ms_and_generic().verified_stmt( "INSERT INTO customers (name, email) OUTPUT INSERTED.id, INSERTED.name INTO @new_ids VALUES ('John', 'john@example.com')", ); } #[test] fn parse_mssql_delete_with_output() { ms_and_generic().verified_stmt("DELETE FROM customers OUTPUT DELETED.* WHERE id = 1"); } #[test] fn parse_mssql_delete_with_output_into() { ms_and_generic().verified_stmt( "DELETE FROM customers OUTPUT DELETED.id, DELETED.name INTO @deleted_rows WHERE active = 0", ); } #[test] fn parse_mssql_update_with_output() { ms_and_generic().verified_stmt( "UPDATE employees SET salary = salary * 1.1 OUTPUT INSERTED.id, DELETED.salary, INSERTED.salary WHERE department = 'Engineering'", ); } #[test] fn parse_mssql_update_with_output_into() { ms_and_generic().verified_stmt( "UPDATE employees SET salary = salary * 1.1 OUTPUT INSERTED.id, DELETED.salary, INSERTED.salary INTO @changes WHERE department = 'Engineering'", ); } #[test] fn test_collate_on_compound_identifier() { ms_and_generic().verified_stmt("SELECT t1.a COLLATE Latin1_General_CI_AS FROM t1"); } #[test] fn parse_mssql_money_constants() { ms().verified_only_select("SELECT CEILING($123.45)"); let select = ms().verified_only_select("SELECT $123.45"); assert_eq!( &Expr::Value(Value::Placeholder("$123.45".to_string()).with_empty_span()), expr_from_projection(only(&select.projection)), ); let select = ms().verified_only_select("SELECT $0.99"); assert_eq!( &Expr::Value(Value::Placeholder("$0.99".to_string()).with_empty_span()), expr_from_projection(only(&select.projection)), ); let select = ms().verified_only_select("SELECT $0.0"); assert_eq!( &Expr::Value(Value::Placeholder("$0.0".to_string()).with_empty_span()), expr_from_projection(only(&select.projection)), ); let select = ms().verified_only_select("SELECT $123"); assert_eq!( &Expr::Value(Value::Placeholder("$123".to_string()).with_empty_span()), expr_from_projection(only(&select.projection)), ); let select = ms().verified_only_select("SELECT $0"); assert_eq!( &Expr::Value(Value::Placeholder("$0".to_string()).with_empty_span()), expr_from_projection(only(&select.projection)), ); } apache-datafusion-sqlparser-rs-0.62.0/tests/sqlparser_mysql.rs000066400000000000000000005424071517524037000246000ustar00rootroot00000000000000// 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. #![warn(clippy::all)] //! Test SQL syntax specific to MySQL. The parser based on the generic dialect //! is also tested (on the inputs it can handle). use helpers::attached_token::AttachedToken; use matches::assert_matches; use sqlparser::ast::MysqlInsertPriority::{Delayed, HighPriority, LowPriority}; use sqlparser::ast::*; use sqlparser::dialect::{GenericDialect, MySqlDialect}; use sqlparser::parser::{ParserError, ParserOptions}; use sqlparser::tokenizer::Span; use sqlparser::tokenizer::Token; use test_utils::*; #[macro_use] mod test_utils; fn mysql() -> TestedDialects { TestedDialects::new(vec![Box::new(MySqlDialect {})]) } fn mysql_and_generic() -> TestedDialects { TestedDialects::new(vec![Box::new(MySqlDialect {}), Box::new(GenericDialect {})]) } #[test] fn parse_identifiers() { mysql().verified_stmt("SELECT $a$, àà"); } #[test] fn parse_literal_string() { let sql = r#"SELECT 'single', "double""#; let select = mysql().verified_only_select(sql); assert_eq!(2, select.projection.len()); assert_eq!( &Expr::Value((Value::SingleQuotedString("single".to_string())).with_empty_span()), expr_from_projection(&select.projection[0]) ); assert_eq!( &Expr::Value((Value::DoubleQuotedString("double".to_string())).with_empty_span()), expr_from_projection(&select.projection[1]) ); } #[test] fn parse_flush() { assert_eq!( mysql_and_generic().verified_stmt("FLUSH OPTIMIZER_COSTS"), Statement::Flush { location: None, object_type: FlushType::OptimizerCosts, channel: None, read_lock: false, export: false, tables: vec![] } ); assert_eq!( mysql_and_generic().verified_stmt("FLUSH BINARY LOGS"), Statement::Flush { location: None, object_type: FlushType::BinaryLogs, channel: None, read_lock: false, export: false, tables: vec![] } ); assert_eq!( mysql_and_generic().verified_stmt("FLUSH ENGINE LOGS"), Statement::Flush { location: None, object_type: FlushType::EngineLogs, channel: None, read_lock: false, export: false, tables: vec![] } ); assert_eq!( mysql_and_generic().verified_stmt("FLUSH ERROR LOGS"), Statement::Flush { location: None, object_type: FlushType::ErrorLogs, channel: None, read_lock: false, export: false, tables: vec![] } ); assert_eq!( mysql_and_generic().verified_stmt("FLUSH NO_WRITE_TO_BINLOG GENERAL LOGS"), Statement::Flush { location: Some(FlushLocation::NoWriteToBinlog), object_type: FlushType::GeneralLogs, channel: None, read_lock: false, export: false, tables: vec![] } ); assert_eq!( mysql_and_generic().verified_stmt("FLUSH RELAY LOGS FOR CHANNEL test"), Statement::Flush { location: None, object_type: FlushType::RelayLogs, channel: Some("test".to_string()), read_lock: false, export: false, tables: vec![] } ); assert_eq!( mysql_and_generic().verified_stmt("FLUSH LOCAL SLOW LOGS"), Statement::Flush { location: Some(FlushLocation::Local), object_type: FlushType::SlowLogs, channel: None, read_lock: false, export: false, tables: vec![] } ); assert_eq!( mysql_and_generic().verified_stmt("FLUSH TABLES `mek`.`table1`, table2"), Statement::Flush { location: None, object_type: FlushType::Tables, channel: None, read_lock: false, export: false, tables: vec![ ObjectName::from(vec![ Ident { value: "mek".to_string(), quote_style: Some('`'), span: Span::empty(), }, Ident { value: "table1".to_string(), quote_style: Some('`'), span: Span::empty(), } ]), ObjectName::from(vec![Ident { value: "table2".to_string(), quote_style: None, span: Span::empty(), }]) ] } ); assert_eq!( mysql_and_generic().verified_stmt("FLUSH TABLES WITH READ LOCK"), Statement::Flush { location: None, object_type: FlushType::Tables, channel: None, read_lock: true, export: false, tables: vec![] } ); assert_eq!( mysql_and_generic().verified_stmt("FLUSH TABLES `mek`.`table1`, table2 WITH READ LOCK"), Statement::Flush { location: None, object_type: FlushType::Tables, channel: None, read_lock: true, export: false, tables: vec![ ObjectName::from(vec![ Ident { value: "mek".to_string(), quote_style: Some('`'), span: Span::empty(), }, Ident { value: "table1".to_string(), quote_style: Some('`'), span: Span::empty(), } ]), ObjectName::from(vec![Ident { value: "table2".to_string(), quote_style: None, span: Span::empty(), }]) ] } ); assert_eq!( mysql_and_generic().verified_stmt("FLUSH TABLES `mek`.`table1`, table2 FOR EXPORT"), Statement::Flush { location: None, object_type: FlushType::Tables, channel: None, read_lock: false, export: true, tables: vec![ ObjectName::from(vec![ Ident { value: "mek".to_string(), quote_style: Some('`'), span: Span::empty(), }, Ident { value: "table1".to_string(), quote_style: Some('`'), span: Span::empty(), } ]), ObjectName::from(vec![Ident { value: "table2".to_string(), quote_style: None, span: Span::empty(), }]) ] } ); } #[test] fn parse_show_columns() { assert_eq!( mysql_and_generic().verified_stmt("SHOW COLUMNS FROM mytable"), Statement::ShowColumns { extended: false, full: false, show_options: ShowStatementOptions { show_in: Some(ShowStatementIn { clause: ShowStatementInClause::FROM, parent_type: None, parent_name: Some(ObjectName::from(vec![Ident::new("mytable")])), }), filter_position: None, limit_from: None, limit: None, starts_with: None, } } ); assert_eq!( mysql_and_generic().verified_stmt("SHOW COLUMNS FROM mydb.mytable"), Statement::ShowColumns { extended: false, full: false, show_options: ShowStatementOptions { show_in: Some(ShowStatementIn { clause: ShowStatementInClause::FROM, parent_type: None, parent_name: Some(ObjectName::from(vec![ Ident::new("mydb"), Ident::new("mytable") ])), }), filter_position: None, limit_from: None, limit: None, starts_with: None, } } ); assert_eq!( mysql_and_generic().verified_stmt("SHOW EXTENDED COLUMNS FROM mytable"), Statement::ShowColumns { extended: true, full: false, show_options: ShowStatementOptions { show_in: Some(ShowStatementIn { clause: ShowStatementInClause::FROM, parent_type: None, parent_name: Some(ObjectName::from(vec![Ident::new("mytable")])), }), filter_position: None, limit_from: None, limit: None, starts_with: None, } } ); assert_eq!( mysql_and_generic().verified_stmt("SHOW FULL COLUMNS FROM mytable"), Statement::ShowColumns { extended: false, full: true, show_options: ShowStatementOptions { show_in: Some(ShowStatementIn { clause: ShowStatementInClause::FROM, parent_type: None, parent_name: Some(ObjectName::from(vec![Ident::new("mytable")])), }), filter_position: None, limit_from: None, limit: None, starts_with: None, } } ); assert_eq!( mysql_and_generic().verified_stmt("SHOW COLUMNS FROM mytable LIKE 'pattern'"), Statement::ShowColumns { extended: false, full: false, show_options: ShowStatementOptions { show_in: Some(ShowStatementIn { clause: ShowStatementInClause::FROM, parent_type: None, parent_name: Some(ObjectName::from(vec![Ident::new("mytable")])), }), filter_position: Some(ShowStatementFilterPosition::Suffix( ShowStatementFilter::Like("pattern".into()) )), limit_from: None, limit: None, starts_with: None, } } ); assert_eq!( mysql_and_generic().verified_stmt("SHOW COLUMNS FROM mytable WHERE 1 = 2"), Statement::ShowColumns { extended: false, full: false, show_options: ShowStatementOptions { show_in: Some(ShowStatementIn { clause: ShowStatementInClause::FROM, parent_type: None, parent_name: Some(ObjectName::from(vec![Ident::new("mytable")])), }), filter_position: Some(ShowStatementFilterPosition::Suffix( ShowStatementFilter::Where(mysql_and_generic().verified_expr("1 = 2")) )), limit_from: None, limit: None, starts_with: None, } } ); mysql_and_generic() .one_statement_parses_to("SHOW FIELDS FROM mytable", "SHOW COLUMNS FROM mytable"); mysql_and_generic() .one_statement_parses_to("SHOW COLUMNS IN mytable", "SHOW COLUMNS IN mytable"); mysql_and_generic() .one_statement_parses_to("SHOW FIELDS IN mytable", "SHOW COLUMNS IN mytable"); mysql_and_generic().one_statement_parses_to( "SHOW COLUMNS FROM mytable FROM mydb", "SHOW COLUMNS FROM mydb.mytable", ); } #[test] fn parse_show_process_list() { assert_eq!( mysql_and_generic().verified_stmt("SHOW PROCESSLIST"), Statement::ShowProcessList { full: false } ); assert_eq!( mysql_and_generic().verified_stmt("SHOW FULL PROCESSLIST"), Statement::ShowProcessList { full: true } ); } #[test] fn parse_show_status() { assert_eq!( mysql_and_generic().verified_stmt("SHOW SESSION STATUS LIKE 'ssl_cipher'"), Statement::ShowStatus { filter: Some(ShowStatementFilter::Like("ssl_cipher".into())), session: true, global: false } ); assert_eq!( mysql_and_generic().verified_stmt("SHOW GLOBAL STATUS LIKE 'ssl_cipher'"), Statement::ShowStatus { filter: Some(ShowStatementFilter::Like("ssl_cipher".into())), session: false, global: true } ); assert_eq!( mysql_and_generic().verified_stmt("SHOW STATUS WHERE value = 2"), Statement::ShowStatus { filter: Some(ShowStatementFilter::Where( mysql_and_generic().verified_expr("value = 2") )), session: false, global: false } ); } #[test] fn parse_show_tables() { assert_eq!( mysql_and_generic().verified_stmt("SHOW TABLES"), Statement::ShowTables { terse: false, history: false, extended: false, full: false, external: false, show_options: ShowStatementOptions { starts_with: None, limit: None, limit_from: None, show_in: None, filter_position: None } } ); assert_eq!( mysql_and_generic().verified_stmt("SHOW TABLES FROM mydb"), Statement::ShowTables { terse: false, history: false, extended: false, full: false, external: false, show_options: ShowStatementOptions { starts_with: None, limit: None, limit_from: None, show_in: Some(ShowStatementIn { clause: ShowStatementInClause::FROM, parent_type: None, parent_name: Some(ObjectName::from(vec![Ident::new("mydb")])), }), filter_position: None } } ); assert_eq!( mysql_and_generic().verified_stmt("SHOW EXTENDED TABLES"), Statement::ShowTables { terse: false, history: false, extended: true, full: false, external: false, show_options: ShowStatementOptions { starts_with: None, limit: None, limit_from: None, show_in: None, filter_position: None } } ); assert_eq!( mysql_and_generic().verified_stmt("SHOW FULL TABLES"), Statement::ShowTables { terse: false, history: false, extended: false, full: true, external: false, show_options: ShowStatementOptions { starts_with: None, limit: None, limit_from: None, show_in: None, filter_position: None } } ); assert_eq!( mysql_and_generic().verified_stmt("SHOW TABLES LIKE 'pattern'"), Statement::ShowTables { terse: false, history: false, extended: false, full: false, external: false, show_options: ShowStatementOptions { starts_with: None, limit: None, limit_from: None, show_in: None, filter_position: Some(ShowStatementFilterPosition::Suffix( ShowStatementFilter::Like("pattern".into()) )) } } ); assert_eq!( mysql_and_generic().verified_stmt("SHOW TABLES WHERE 1 = 2"), Statement::ShowTables { terse: false, history: false, extended: false, full: false, external: false, show_options: ShowStatementOptions { starts_with: None, limit: None, limit_from: None, show_in: None, filter_position: Some(ShowStatementFilterPosition::Suffix( ShowStatementFilter::Where(mysql_and_generic().verified_expr("1 = 2")) )) } } ); mysql_and_generic().verified_stmt("SHOW TABLES IN mydb"); mysql_and_generic().verified_stmt("SHOW TABLES FROM mydb"); } #[test] fn parse_show_extended_full() { assert!(mysql_and_generic() .parse_sql_statements("SHOW EXTENDED FULL TABLES") .is_ok()); assert!(mysql_and_generic() .parse_sql_statements("SHOW EXTENDED FULL COLUMNS FROM mytable") .is_ok()); // SHOW EXTENDED/FULL can only be used with COLUMNS and TABLES assert!(mysql_and_generic() .parse_sql_statements("SHOW EXTENDED FULL CREATE TABLE mytable") .is_err()); assert!(mysql_and_generic() .parse_sql_statements("SHOW EXTENDED FULL COLLATION") .is_err()); assert!(mysql_and_generic() .parse_sql_statements("SHOW EXTENDED FULL VARIABLES") .is_err()); } #[test] fn parse_show_create() { let obj_name = ObjectName::from(vec![Ident::new("myident")]); for obj_type in &[ ShowCreateObject::Table, ShowCreateObject::Trigger, ShowCreateObject::Event, ShowCreateObject::Function, ShowCreateObject::Procedure, ShowCreateObject::View, ] { assert_eq!( mysql_and_generic().verified_stmt(format!("SHOW CREATE {obj_type} myident").as_str()), Statement::ShowCreate { obj_type: *obj_type, obj_name: obj_name.clone(), } ); } } #[test] fn parse_show_collation() { assert_eq!( mysql_and_generic().verified_stmt("SHOW COLLATION"), Statement::ShowCollation { filter: None } ); assert_eq!( mysql_and_generic().verified_stmt("SHOW COLLATION LIKE 'pattern'"), Statement::ShowCollation { filter: Some(ShowStatementFilter::Like("pattern".into())), } ); assert_eq!( mysql_and_generic().verified_stmt("SHOW COLLATION WHERE 1 = 2"), Statement::ShowCollation { filter: Some(ShowStatementFilter::Where( mysql_and_generic().verified_expr("1 = 2") )), } ); } #[test] fn parse_use() { let valid_object_names = [ "mydb", "SCHEMA", "DATABASE", "CATALOG", "WAREHOUSE", "DEFAULT", ]; let quote_styles = ['\'', '"', '`']; for object_name in &valid_object_names { // Test single identifier without quotes assert_eq!( mysql_and_generic().verified_stmt(&format!("USE {object_name}")), Statement::Use(Use::Object(ObjectName::from(vec![Ident::new( object_name.to_string() )]))) ); for "e in "e_styles { // Test single identifier with different type of quotes assert_eq!( mysql_and_generic().verified_stmt(&format!("USE {quote}{object_name}{quote}")), Statement::Use(Use::Object(ObjectName::from(vec![Ident::with_quote( quote, object_name.to_string(), )]))) ); } } } #[test] fn parse_set_variables() { mysql_and_generic().verified_stmt("SET sql_mode = CONCAT(@@sql_mode, ',STRICT_TRANS_TABLES')"); assert_eq!( mysql_and_generic().verified_stmt("SET LOCAL autocommit = 1"), Statement::Set(Set::SingleAssignment { scope: Some(ContextModifier::Local), hivevar: false, variable: ObjectName::from(vec!["autocommit".into()]), values: vec![Expr::value(number("1"))], }) ); } #[test] fn parse_create_table_auto_increment() { let sql = "CREATE TABLE foo (bar INT PRIMARY KEY AUTO_INCREMENT)"; match mysql().verified_stmt(sql) { Statement::CreateTable(CreateTable { name, columns, .. }) => { assert_eq!(name.to_string(), "foo"); assert_eq!( vec![ColumnDef { name: Ident::new("bar"), data_type: DataType::Int(None), options: vec![ ColumnOptionDef { name: None, option: ColumnOption::PrimaryKey(PrimaryKeyConstraint { name: None, index_name: None, index_type: None, columns: vec![], index_options: vec![], characteristics: None, }), }, ColumnOptionDef { name: None, option: ColumnOption::DialectSpecific(vec![Token::make_keyword( "AUTO_INCREMENT" )]), }, ], }], columns ); } _ => unreachable!(), } } /// if `unique_index_type_display` is `Some` create `TableConstraint::Unique` /// otherwise create `TableConstraint::Primary` fn table_constraint_unique_primary_ctor( name: Option, index_name: Option, index_type: Option, columns: Vec, index_options: Vec, characteristics: Option, unique_index_type_display: Option, ) -> TableConstraint { let columns = columns .into_iter() .map(|ident| IndexColumn { column: OrderByExpr { expr: Expr::Identifier(ident), options: OrderByOptions { asc: None, nulls_first: None, }, with_fill: None, }, operator_class: None, }) .collect(); match unique_index_type_display { Some(index_type_display) => UniqueConstraint { name, index_name, index_type_display, index_type, columns, index_options, characteristics, nulls_distinct: NullsDistinctOption::None, } .into(), None => PrimaryKeyConstraint { name, index_name, index_type, columns, index_options, characteristics, } .into(), } } #[test] fn parse_create_table_primary_and_unique_key() { let sqls = ["UNIQUE KEY", "PRIMARY KEY"] .map(|key_ty| format!("CREATE TABLE foo (id INT PRIMARY KEY AUTO_INCREMENT, bar INT NOT NULL, CONSTRAINT bar_key {key_ty} (bar))")); let index_type_display = [Some(KeyOrIndexDisplay::Key), None]; for (sql, index_type_display) in sqls.iter().zip(index_type_display) { match mysql().one_statement_parses_to(sql, "") { Statement::CreateTable(CreateTable { name, columns, constraints, .. }) => { assert_eq!(name.to_string(), "foo"); let expected_constraint = table_constraint_unique_primary_ctor( Some(Ident::new("bar_key")), None, None, vec![Ident::new("bar")], vec![], None, index_type_display, ); assert_eq!(vec![expected_constraint], constraints); assert_eq!( vec![ ColumnDef { name: Ident::new("id"), data_type: DataType::Int(None), options: vec![ ColumnOptionDef { name: None, option: ColumnOption::PrimaryKey(PrimaryKeyConstraint { name: None, index_name: None, index_type: None, columns: vec![], index_options: vec![], characteristics: None, }), }, ColumnOptionDef { name: None, option: ColumnOption::DialectSpecific(vec![ Token::make_keyword("AUTO_INCREMENT") ]), }, ], }, ColumnDef { name: Ident::new("bar"), data_type: DataType::Int(None), options: vec![ColumnOptionDef { name: None, option: ColumnOption::NotNull, },], }, ], columns ); } _ => unreachable!(), } } } #[test] fn parse_create_table_primary_and_unique_key_with_index_options() { let sqls = ["UNIQUE INDEX", "PRIMARY KEY"] .map(|key_ty| format!("CREATE TABLE foo (bar INT, var INT, CONSTRAINT constr {key_ty} index_name (bar, var) USING HASH COMMENT 'yes, ' USING BTREE COMMENT 'MySQL allows')")); let index_type_display = [Some(KeyOrIndexDisplay::Index), None]; for (sql, index_type_display) in sqls.iter().zip(index_type_display) { match mysql_and_generic().one_statement_parses_to(sql, "") { Statement::CreateTable(CreateTable { name, constraints, .. }) => { assert_eq!(name.to_string(), "foo"); let expected_constraint = table_constraint_unique_primary_ctor( Some(Ident::new("constr")), Some(Ident::new("index_name")), None, vec![Ident::new("bar"), Ident::new("var")], vec![ IndexOption::Using(IndexType::Hash), IndexOption::Comment("yes, ".into()), IndexOption::Using(IndexType::BTree), IndexOption::Comment("MySQL allows".into()), ], None, index_type_display, ); assert_eq!(vec![expected_constraint], constraints); } _ => unreachable!(), } mysql_and_generic().verified_stmt(sql); } } #[test] fn parse_prefix_key_part() { let expected = vec![FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::value( number("10"), )))]; for sql in [ "CREATE INDEX idx_index ON t(textcol(10))", "ALTER TABLE tab ADD INDEX idx_index (textcol(10))", "ALTER TABLE tab ADD PRIMARY KEY (textcol(10))", "ALTER TABLE tab ADD UNIQUE KEY (textcol(10))", "ALTER TABLE tab ADD UNIQUE KEY (textcol(10))", "ALTER TABLE tab ADD FULLTEXT INDEX (textcol(10))", "CREATE TABLE t (textcol TEXT, INDEX idx_index (textcol(10)))", ] { match index_column(mysql_and_generic().verified_stmt(sql)) { Expr::Function(Function { name, args: FunctionArguments::List(FunctionArgumentList { args, .. }), .. }) => { assert_eq!(name.to_string(), "textcol"); assert_eq!(args, expected); } expr => panic!("unexpected expression {expr} for {sql}"), } } } #[test] fn test_functional_key_part() { assert_eq!( index_column( mysql_and_generic() .verified_stmt("CREATE INDEX idx_index ON t((col COLLATE utf8mb4_bin) DESC)") ), Expr::Nested(Box::new(Expr::Collate { expr: Box::new(Expr::Identifier("col".into())), collation: ObjectName(vec![sqlparser::ast::ObjectNamePart::Identifier( Ident::new("utf8mb4_bin") )]), })) ); assert_eq!( index_column(mysql_and_generic().verified_stmt( r#"CREATE TABLE t (jsoncol JSON, PRIMARY KEY ((CAST(col ->> '$.id' AS UNSIGNED)) ASC))"# )), Expr::Nested(Box::new(Expr::Cast { kind: CastKind::Cast, expr: Box::new(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("col"))), op: BinaryOperator::LongArrow, right: Box::new(Expr::Value( Value::SingleQuotedString("$.id".to_string()).with_empty_span() )), }), data_type: DataType::Unsigned, array: false, format: None, })), ); assert_eq!( index_column(mysql_and_generic().verified_stmt( r#"CREATE TABLE t (jsoncol JSON, PRIMARY KEY ((CAST(col ->> '$.fields' AS UNSIGNED ARRAY)) ASC))"# )), Expr::Nested(Box::new(Expr::Cast { kind: CastKind::Cast, expr: Box::new(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("col"))), op: BinaryOperator::LongArrow, right: Box::new(Expr::Value( Value::SingleQuotedString("$.fields".to_string()).with_empty_span() )), }), data_type: DataType::Unsigned, array: true, format: None, })), ); } #[test] fn parse_create_table_primary_and_unique_key_with_index_type() { let sqls = ["UNIQUE", "PRIMARY KEY"].map(|key_ty| { format!("CREATE TABLE foo (bar INT, {key_ty} index_name USING BTREE (bar) USING HASH)") }); let index_type_display = [Some(KeyOrIndexDisplay::None), None]; for (sql, index_type_display) in sqls.iter().zip(index_type_display) { match mysql_and_generic().one_statement_parses_to(sql, "") { Statement::CreateTable(CreateTable { name, constraints, .. }) => { assert_eq!(name.to_string(), "foo"); let expected_constraint = table_constraint_unique_primary_ctor( None, Some(Ident::new("index_name")), Some(IndexType::BTree), vec![Ident::new("bar")], vec![IndexOption::Using(IndexType::Hash)], None, index_type_display, ); assert_eq!(vec![expected_constraint], constraints); } _ => unreachable!(), } mysql_and_generic().verified_stmt(sql); } let sql = "CREATE TABLE foo (bar INT, UNIQUE INDEX index_name USING BTREE (bar) USING HASH)"; mysql_and_generic().verified_stmt(sql); let sql = "CREATE TABLE foo (bar INT, PRIMARY KEY index_name USING BTREE (bar) USING HASH)"; mysql_and_generic().verified_stmt(sql); } #[test] fn parse_create_table_primary_and_unique_key_characteristic_test() { let sqls = ["UNIQUE INDEX", "PRIMARY KEY"] .map(|key_ty| format!("CREATE TABLE x (y INT, CONSTRAINT constr {key_ty} (y) NOT DEFERRABLE INITIALLY IMMEDIATE)")); for sql in &sqls { mysql_and_generic().verified_stmt(sql); } } #[test] fn parse_create_table_column_key_options() { mysql_and_generic().verified_stmt("CREATE TABLE foo (x INT UNIQUE KEY)"); mysql_and_generic().one_statement_parses_to( "CREATE TABLE foo (x INT KEY)", "CREATE TABLE foo (x INT PRIMARY KEY)", ); } #[test] fn parse_create_table_comment() { let without_equal = "CREATE TABLE foo (bar INT) COMMENT 'baz'"; let with_equal = "CREATE TABLE foo (bar INT) COMMENT = 'baz'"; for sql in [without_equal, with_equal] { match mysql().verified_stmt(sql) { Statement::CreateTable(CreateTable { name, table_options, .. }) => { assert_eq!(name.to_string(), "foo"); let plain_options = match table_options { CreateTableOptions::Plain(options) => options, _ => unreachable!(), }; let comment = match plain_options.first().unwrap() { SqlOption::Comment(CommentDef::WithEq(c)) | SqlOption::Comment(CommentDef::WithoutEq(c)) => c, _ => unreachable!(), }; assert_eq!(comment, "baz"); } _ => unreachable!(), } } } #[test] fn parse_create_table_auto_increment_offset() { let sql = "CREATE TABLE foo (bar INT NOT NULL AUTO_INCREMENT) ENGINE = InnoDB AUTO_INCREMENT = 123"; match mysql().verified_stmt(sql) { Statement::CreateTable(CreateTable { name, table_options, .. }) => { assert_eq!(name.to_string(), "foo"); let plain_options = match table_options { CreateTableOptions::Plain(options) => options, _ => unreachable!(), }; assert!(plain_options.contains(&SqlOption::KeyValue { key: Ident::new("AUTO_INCREMENT"), value: Expr::Value(test_utils::number("123").with_empty_span()) })); } _ => unreachable!(), } } #[test] fn parse_create_table_multiple_options_order_independent() { let sql1 = "CREATE TABLE mytable (id INT) ENGINE=InnoDB ROW_FORMAT=DYNAMIC KEY_BLOCK_SIZE=8 COMMENT='abc'"; let sql2 = "CREATE TABLE mytable (id INT) KEY_BLOCK_SIZE=8 COMMENT='abc' ENGINE=InnoDB ROW_FORMAT=DYNAMIC"; let sql3 = "CREATE TABLE mytable (id INT) ROW_FORMAT=DYNAMIC KEY_BLOCK_SIZE=8 COMMENT='abc' ENGINE=InnoDB"; for sql in [sql1, sql2, sql3] { match mysql().parse_sql_statements(sql).unwrap().pop().unwrap() { Statement::CreateTable(CreateTable { name, table_options, .. }) => { assert_eq!(name.to_string(), "mytable"); 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("InnoDB")), values: vec![] } ))); assert!(plain_options.contains(&SqlOption::KeyValue { key: Ident::new("KEY_BLOCK_SIZE"), value: Expr::Value(test_utils::number("8").with_empty_span()) })); assert!(plain_options .contains(&SqlOption::Comment(CommentDef::WithEq("abc".to_owned())))); assert!(plain_options.contains(&SqlOption::KeyValue { key: Ident::new("ROW_FORMAT"), value: Expr::Identifier(Ident::new("DYNAMIC".to_owned())) })); } _ => unreachable!(), } } } #[test] fn parse_create_table_with_all_table_options() { let sql = "CREATE TABLE foo (bar INT NOT NULL AUTO_INCREMENT) ENGINE = InnoDB AUTO_INCREMENT = 123 DEFAULT CHARSET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci INSERT_METHOD = FIRST KEY_BLOCK_SIZE = 8 ROW_FORMAT = DYNAMIC DATA DIRECTORY = '/var/lib/mysql/data' INDEX DIRECTORY = '/var/lib/mysql/index' PACK_KEYS = 1 STATS_AUTO_RECALC = 1 STATS_PERSISTENT = 0 STATS_SAMPLE_PAGES = 128 DELAY_KEY_WRITE = 1 COMPRESSION = 'ZLIB' ENCRYPTION = 'Y' MAX_ROWS = 10000 MIN_ROWS = 10 AUTOEXTEND_SIZE = 64 AVG_ROW_LENGTH = 128 CHECKSUM = 1 CONNECTION = 'mysql://localhost' ENGINE_ATTRIBUTE = 'primary' PASSWORD = 'secure_password' SECONDARY_ENGINE_ATTRIBUTE = 'secondary_attr' START TRANSACTION TABLESPACE my_tablespace STORAGE DISK UNION = (table1, table2, table3)"; match mysql().verified_stmt(sql) { Statement::CreateTable(CreateTable { name, table_options, .. }) => { assert_eq!(name, vec![Ident::new("foo".to_owned())].into()); 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("InnoDB")), values: vec![] } ))); assert!(plain_options.contains(&SqlOption::KeyValue { key: Ident::new("COLLATE"), value: Expr::Identifier(Ident::new("utf8mb4_0900_ai_ci".to_owned())) })); assert!(plain_options.contains(&SqlOption::KeyValue { key: Ident::new("DEFAULT CHARSET"), value: Expr::Identifier(Ident::new("utf8mb4".to_owned())) })); assert!(plain_options.contains(&SqlOption::KeyValue { key: Ident::new("AUTO_INCREMENT"), value: Expr::value(test_utils::number("123")) })); assert!(plain_options.contains(&SqlOption::KeyValue { key: Ident::new("KEY_BLOCK_SIZE"), value: Expr::value(test_utils::number("8")) })); assert!(plain_options.contains(&SqlOption::KeyValue { key: Ident::new("ROW_FORMAT"), value: Expr::Identifier(Ident::new("DYNAMIC".to_owned())) })); assert!(plain_options.contains(&SqlOption::KeyValue { key: Ident::new("PACK_KEYS"), value: Expr::value(test_utils::number("1")) })); assert!(plain_options.contains(&SqlOption::KeyValue { key: Ident::new("STATS_AUTO_RECALC"), value: Expr::value(test_utils::number("1")) })); assert!(plain_options.contains(&SqlOption::KeyValue { key: Ident::new("STATS_PERSISTENT"), value: Expr::value(test_utils::number("0")) })); assert!(plain_options.contains(&SqlOption::KeyValue { key: Ident::new("STATS_SAMPLE_PAGES"), value: Expr::value(test_utils::number("128")) })); assert!(plain_options.contains(&SqlOption::KeyValue { key: Ident::new("STATS_SAMPLE_PAGES"), value: Expr::value(test_utils::number("128")) })); assert!(plain_options.contains(&SqlOption::KeyValue { key: Ident::new("INSERT_METHOD"), value: Expr::Identifier(Ident::new("FIRST".to_owned())) })); assert!(plain_options.contains(&SqlOption::KeyValue { key: Ident::new("COMPRESSION"), value: Expr::value(Value::SingleQuotedString("ZLIB".to_owned())) })); assert!(plain_options.contains(&SqlOption::KeyValue { key: Ident::new("ENCRYPTION"), value: Expr::value(Value::SingleQuotedString("Y".to_owned())) })); assert!(plain_options.contains(&SqlOption::KeyValue { key: Ident::new("MAX_ROWS"), value: Expr::value(test_utils::number("10000")) })); assert!(plain_options.contains(&SqlOption::KeyValue { key: Ident::new("MIN_ROWS"), value: Expr::value(test_utils::number("10")) })); assert!(plain_options.contains(&SqlOption::KeyValue { key: Ident::new("AUTOEXTEND_SIZE"), value: Expr::value(test_utils::number("64")) })); assert!(plain_options.contains(&SqlOption::KeyValue { key: Ident::new("AVG_ROW_LENGTH"), value: Expr::value(test_utils::number("128")) })); assert!(plain_options.contains(&SqlOption::KeyValue { key: Ident::new("CHECKSUM"), value: Expr::value(test_utils::number("1")) })); assert!(plain_options.contains(&SqlOption::KeyValue { key: Ident::new("CONNECTION"), value: Expr::value(Value::SingleQuotedString("mysql://localhost".to_owned())) })); assert!(plain_options.contains(&SqlOption::KeyValue { key: Ident::new("ENGINE_ATTRIBUTE"), value: Expr::value(Value::SingleQuotedString("primary".to_owned())) })); assert!(plain_options.contains(&SqlOption::KeyValue { key: Ident::new("PASSWORD"), value: Expr::value(Value::SingleQuotedString("secure_password".to_owned())) })); assert!(plain_options.contains(&SqlOption::KeyValue { key: Ident::new("SECONDARY_ENGINE_ATTRIBUTE"), value: Expr::value(Value::SingleQuotedString("secondary_attr".to_owned())) })); assert!(plain_options.contains(&SqlOption::Ident(Ident::new( "START TRANSACTION".to_owned() )))); assert!( plain_options.contains(&SqlOption::TableSpace(TablespaceOption { name: "my_tablespace".to_string(), storage: Some(StorageType::Disk), })) ); assert!(plain_options.contains(&SqlOption::NamedParenthesizedList( NamedParenthesizedList { key: Ident::new("UNION"), name: None, values: vec![ Ident::new("table1".to_string()), Ident::new("table2".to_string()), Ident::new("table3".to_string()) ] } ))); assert!(plain_options.contains(&SqlOption::KeyValue { key: Ident::new("DATA DIRECTORY"), value: Expr::value(Value::SingleQuotedString("/var/lib/mysql/data".to_owned())) })); assert!(plain_options.contains(&SqlOption::KeyValue { key: Ident::new("INDEX DIRECTORY"), value: Expr::value(Value::SingleQuotedString("/var/lib/mysql/index".to_owned())) })); } _ => unreachable!(), } } #[test] fn parse_create_table_set_enum() { let sql = "CREATE TABLE foo (bar SET('a', 'b'), baz ENUM('a', 'b'))"; match mysql().verified_stmt(sql) { Statement::CreateTable(CreateTable { name, columns, .. }) => { assert_eq!(name.to_string(), "foo"); assert_eq!( vec![ ColumnDef { name: Ident::new("bar"), data_type: DataType::Set(vec!["a".to_string(), "b".to_string()]), options: vec![], }, ColumnDef { name: Ident::new("baz"), data_type: DataType::Enum( vec![ EnumMember::Name("a".to_string()), EnumMember::Name("b".to_string()) ], None ), options: vec![], } ], columns ); } _ => unreachable!(), } } #[test] fn parse_create_table_engine_default_charset() { let sql = "CREATE TABLE foo (id INT(11)) ENGINE = InnoDB DEFAULT CHARSET = utf8mb3"; match mysql().verified_stmt(sql) { Statement::CreateTable(CreateTable { name, columns, table_options, .. }) => { assert_eq!(name.to_string(), "foo"); assert_eq!( vec![ColumnDef { name: Ident::new("id"), data_type: DataType::Int(Some(11)), options: vec![], },], columns ); let plain_options = match table_options { CreateTableOptions::Plain(options) => options, _ => unreachable!(), }; assert!(plain_options.contains(&SqlOption::KeyValue { key: Ident::new("DEFAULT CHARSET"), value: Expr::Identifier(Ident::new("utf8mb3".to_owned())) })); assert!(plain_options.contains(&SqlOption::NamedParenthesizedList( NamedParenthesizedList { key: Ident::new("ENGINE"), name: Some(Ident::new("InnoDB")), values: vec![] } ))); } _ => unreachable!(), } } #[test] fn parse_create_table_collate() { let sql = "CREATE TABLE foo (id INT(11)) COLLATE = utf8mb4_0900_ai_ci"; match mysql().verified_stmt(sql) { Statement::CreateTable(CreateTable { name, columns, table_options, .. }) => { assert_eq!(name.to_string(), "foo"); assert_eq!( vec![ColumnDef { name: Ident::new("id"), data_type: DataType::Int(Some(11)), options: vec![], },], columns ); let plain_options = match table_options { CreateTableOptions::Plain(options) => options, _ => unreachable!(), }; assert!(plain_options.contains(&SqlOption::KeyValue { key: Ident::new("COLLATE"), value: Expr::Identifier(Ident::new("utf8mb4_0900_ai_ci".to_owned())) })); } _ => unreachable!(), } } #[test] fn parse_create_table_both_options_and_as_query() { let sql = "CREATE TABLE foo (id INT(11)) ENGINE = InnoDB DEFAULT CHARSET = utf8mb3 COLLATE = utf8mb4_0900_ai_ci AS SELECT 1"; match mysql_and_generic().verified_stmt(sql) { Statement::CreateTable(CreateTable { name, query, table_options, .. }) => { assert_eq!(name.to_string(), "foo"); let plain_options = match table_options { CreateTableOptions::Plain(options) => options, _ => unreachable!(), }; assert!(plain_options.contains(&SqlOption::KeyValue { key: Ident::new("COLLATE"), value: Expr::Identifier(Ident::new("utf8mb4_0900_ai_ci".to_owned())) })); assert_eq!( query.unwrap().body.as_select().unwrap().projection, vec![SelectItem::UnnamedExpr(Expr::Value( (number("1")).with_empty_span() ))] ); } _ => unreachable!(), } let sql = r"CREATE TABLE foo (id INT(11)) ENGINE = InnoDB AS SELECT 1 DEFAULT CHARSET = utf8mb3"; assert!(matches!( mysql_and_generic().parse_sql_statements(sql), Err(ParserError::ParserError(_)) )); } #[test] fn parse_create_table_comment_character_set() { let sql = "CREATE TABLE foo (s TEXT CHARACTER SET utf8mb4 COMMENT 'comment')"; match mysql().verified_stmt(sql) { Statement::CreateTable(CreateTable { name, columns, .. }) => { assert_eq!(name.to_string(), "foo"); assert_eq!( vec![ColumnDef { name: Ident::new("s"), data_type: DataType::Text, options: vec![ ColumnOptionDef { name: None, option: ColumnOption::CharacterSet(ObjectName::from(vec![Ident::new( "utf8mb4" )])) }, ColumnOptionDef { name: None, option: ColumnOption::Comment("comment".to_string()) } ], },], columns ); } _ => unreachable!(), } } #[test] fn parse_create_table_gencol() { let sql_default = "CREATE TABLE t1 (a INT, b INT GENERATED ALWAYS AS (a * 2))"; mysql_and_generic().verified_stmt(sql_default); let sql_virt = "CREATE TABLE t1 (a INT, b INT GENERATED ALWAYS AS (a * 2) VIRTUAL)"; mysql_and_generic().verified_stmt(sql_virt); let sql_stored = "CREATE TABLE t1 (a INT, b INT GENERATED ALWAYS AS (a * 2) STORED)"; mysql_and_generic().verified_stmt(sql_stored); mysql_and_generic().verified_stmt("CREATE TABLE t1 (a INT, b INT AS (a * 2))"); mysql_and_generic().verified_stmt("CREATE TABLE t1 (a INT, b INT AS (a * 2) VIRTUAL)"); mysql_and_generic().verified_stmt("CREATE TABLE t1 (a INT, b INT AS (a * 2) STORED)"); } #[test] fn parse_create_table_options_comma_separated() { let sql = "CREATE TABLE t (x INT) DEFAULT CHARSET = utf8mb4, ENGINE = InnoDB , AUTO_INCREMENT 1 DATA DIRECTORY '/var/lib/mysql/data'"; let canonical = "CREATE TABLE t (x INT) DEFAULT CHARSET = utf8mb4 ENGINE = InnoDB AUTO_INCREMENT = 1 DATA DIRECTORY = '/var/lib/mysql/data'"; mysql_and_generic().one_statement_parses_to(sql, canonical); } #[test] fn parse_quote_identifiers() { let sql = "CREATE TABLE `PRIMARY` (`BEGIN` INT PRIMARY KEY)"; match mysql().verified_stmt(sql) { Statement::CreateTable(CreateTable { name, columns, .. }) => { assert_eq!(name.to_string(), "`PRIMARY`"); assert_eq!( vec![ColumnDef { name: Ident::with_quote('`', "BEGIN"), data_type: DataType::Int(None), options: vec![ColumnOptionDef { name: None, option: ColumnOption::PrimaryKey(PrimaryKeyConstraint { name: None, index_name: None, index_type: None, columns: vec![], index_options: vec![], characteristics: None, }), }], }], columns ); } _ => unreachable!(), } } #[test] fn parse_escaped_quote_identifiers_with_escape() { let sql = "SELECT `quoted `` identifier`"; assert_eq!( TestedDialects::new(vec![Box::new(MySqlDialect {})]).verified_stmt(sql), Statement::Query(Box::new(Query { with: None, body: Box::new(SetExpr::Select(Box::new(Select { select_token: AttachedToken::empty(), optimizer_hints: vec![], distinct: None, select_modifiers: None, top: None, top_before_distinct: false, projection: vec![SelectItem::UnnamedExpr(Expr::Identifier(Ident { value: "quoted ` identifier".into(), quote_style: Some('`'), span: Span::empty(), }))], exclude: None, into: None, from: vec![], lateral_views: vec![], prewhere: None, selection: None, group_by: GroupByExpr::Expressions(vec![], vec![]), cluster_by: vec![], distribute_by: vec![], sort_by: vec![], having: None, named_window: vec![], qualify: None, window_before_qualify: false, value_table_mode: None, connect_by: vec![], flavor: SelectFlavor::Standard, }))), order_by: None, limit_clause: None, fetch: None, locks: vec![], for_clause: None, settings: None, format_clause: None, pipe_operators: vec![], })) ); } #[test] fn parse_escaped_quote_identifiers_with_no_escape() { let sql = "SELECT `quoted `` identifier`"; assert_eq!( TestedDialects::new_with_options( vec![Box::new(MySqlDialect {})], ParserOptions { trailing_commas: false, unescape: false, require_semicolon_stmt_delimiter: true, } ) .verified_stmt(sql), Statement::Query(Box::new(Query { with: None, body: Box::new(SetExpr::Select(Box::new(Select { select_token: AttachedToken::empty(), optimizer_hints: vec![], distinct: None, select_modifiers: None, top: None, top_before_distinct: false, projection: vec![SelectItem::UnnamedExpr(Expr::Identifier(Ident { value: "quoted `` identifier".into(), quote_style: Some('`'), span: Span::empty(), }))], exclude: None, into: None, from: vec![], lateral_views: vec![], prewhere: None, selection: None, group_by: GroupByExpr::Expressions(vec![], vec![]), cluster_by: vec![], distribute_by: vec![], sort_by: vec![], having: None, named_window: vec![], qualify: None, window_before_qualify: false, value_table_mode: None, connect_by: vec![], flavor: SelectFlavor::Standard, }))), order_by: None, limit_clause: None, fetch: None, locks: vec![], for_clause: None, settings: None, format_clause: None, pipe_operators: vec![], })) ); } #[test] fn parse_escaped_backticks_with_escape() { let sql = "SELECT ```quoted identifier```"; assert_eq!( TestedDialects::new(vec![Box::new(MySqlDialect {})]).verified_stmt(sql), Statement::Query(Box::new(Query { with: None, body: Box::new(SetExpr::Select(Box::new(Select { select_token: AttachedToken::empty(), optimizer_hints: vec![], distinct: None, select_modifiers: None, top: None, top_before_distinct: false, projection: vec![SelectItem::UnnamedExpr(Expr::Identifier(Ident { value: "`quoted identifier`".into(), quote_style: Some('`'), span: Span::empty(), }))], exclude: None, into: None, from: vec![], lateral_views: vec![], prewhere: None, selection: None, group_by: GroupByExpr::Expressions(vec![], vec![]), cluster_by: vec![], distribute_by: vec![], sort_by: vec![], having: None, named_window: vec![], qualify: None, window_before_qualify: false, value_table_mode: None, connect_by: vec![], flavor: SelectFlavor::Standard, }))), order_by: None, limit_clause: None, fetch: None, locks: vec![], for_clause: None, settings: None, format_clause: None, pipe_operators: vec![], })) ); } #[test] fn parse_escaped_backticks_with_no_escape() { let sql = "SELECT ```quoted identifier```"; assert_eq!( TestedDialects::new_with_options( vec![Box::new(MySqlDialect {})], ParserOptions::new().with_unescape(false) ) .verified_stmt(sql), Statement::Query(Box::new(Query { with: None, body: Box::new(SetExpr::Select(Box::new(Select { select_token: AttachedToken::empty(), optimizer_hints: vec![], distinct: None, select_modifiers: None, top: None, top_before_distinct: false, projection: vec![SelectItem::UnnamedExpr(Expr::Identifier(Ident { value: "``quoted identifier``".into(), quote_style: Some('`'), span: Span::empty(), }))], exclude: None, into: None, from: vec![], lateral_views: vec![], prewhere: None, selection: None, group_by: GroupByExpr::Expressions(vec![], vec![]), cluster_by: vec![], distribute_by: vec![], sort_by: vec![], having: None, named_window: vec![], qualify: None, window_before_qualify: false, value_table_mode: None, connect_by: vec![], flavor: SelectFlavor::Standard, }))), order_by: None, limit_clause: None, fetch: None, locks: vec![], for_clause: None, settings: None, format_clause: None, pipe_operators: vec![], })) ); } #[test] fn parse_unterminated_escape() { let sql = r"SELECT 'I\'m not fine\'"; let result = std::panic::catch_unwind(|| mysql().one_statement_parses_to(sql, "")); assert!(result.is_err()); let sql = r"SELECT 'I\\'m not fine'"; let result = std::panic::catch_unwind(|| mysql().one_statement_parses_to(sql, "")); assert!(result.is_err()); } #[test] fn check_roundtrip_of_escaped_string() { let options = ParserOptions::new().with_unescape(false); TestedDialects::new_with_options(vec![Box::new(MySqlDialect {})], options.clone()) .verified_stmt(r"SELECT 'I\'m fine'"); TestedDialects::new_with_options(vec![Box::new(MySqlDialect {})], options.clone()) .verified_stmt(r#"SELECT 'I''m fine'"#); TestedDialects::new_with_options(vec![Box::new(MySqlDialect {})], options.clone()) .verified_stmt(r"SELECT 'I\\\'m fine'"); TestedDialects::new_with_options(vec![Box::new(MySqlDialect {})], options.clone()) .verified_stmt(r"SELECT 'I\\\'m fine'"); TestedDialects::new_with_options(vec![Box::new(MySqlDialect {})], options.clone()) .verified_stmt(r#"SELECT "I\"m fine""#); TestedDialects::new_with_options(vec![Box::new(MySqlDialect {})], options.clone()) .verified_stmt(r#"SELECT "I""m fine""#); TestedDialects::new_with_options(vec![Box::new(MySqlDialect {})], options.clone()) .verified_stmt(r#"SELECT "I\\\"m fine""#); TestedDialects::new_with_options(vec![Box::new(MySqlDialect {})], options.clone()) .verified_stmt(r#"SELECT "I\\\"m fine""#); TestedDialects::new_with_options(vec![Box::new(MySqlDialect {})], options.clone()) .verified_stmt(r#"SELECT "I'm ''fine''""#); } #[test] fn parse_create_table_with_minimum_display_width() { let sql = "CREATE TABLE foo (bar_tinyint TINYINT(3), bar_smallint SMALLINT(5), bar_mediumint MEDIUMINT(6), bar_int INT(11), bar_bigint BIGINT(20))"; match mysql().verified_stmt(sql) { Statement::CreateTable(CreateTable { name, columns, .. }) => { assert_eq!(name.to_string(), "foo"); assert_eq!( vec![ ColumnDef { name: Ident::new("bar_tinyint"), data_type: DataType::TinyInt(Some(3)), options: vec![], }, ColumnDef { name: Ident::new("bar_smallint"), data_type: DataType::SmallInt(Some(5)), options: vec![], }, ColumnDef { name: Ident::new("bar_mediumint"), data_type: DataType::MediumInt(Some(6)), options: vec![], }, ColumnDef { name: Ident::new("bar_int"), data_type: DataType::Int(Some(11)), options: vec![], }, ColumnDef { name: Ident::new("bar_bigint"), data_type: DataType::BigInt(Some(20)), options: vec![], } ], columns ); } _ => unreachable!(), } } #[test] fn parse_create_table_unsigned() { let sql = "CREATE TABLE foo (bar_tinyint TINYINT(3) UNSIGNED, bar_smallint SMALLINT(5) UNSIGNED, bar_mediumint MEDIUMINT(13) UNSIGNED, bar_int INT(11) UNSIGNED, bar_bigint BIGINT(20) UNSIGNED)"; match mysql().verified_stmt(sql) { Statement::CreateTable(CreateTable { name, columns, .. }) => { assert_eq!(name.to_string(), "foo"); assert_eq!( vec![ ColumnDef { name: Ident::new("bar_tinyint"), data_type: DataType::TinyIntUnsigned(Some(3)), options: vec![], }, ColumnDef { name: Ident::new("bar_smallint"), data_type: DataType::SmallIntUnsigned(Some(5)), options: vec![], }, ColumnDef { name: Ident::new("bar_mediumint"), data_type: DataType::MediumIntUnsigned(Some(13)), options: vec![], }, ColumnDef { name: Ident::new("bar_int"), data_type: DataType::IntUnsigned(Some(11)), options: vec![], }, ColumnDef { name: Ident::new("bar_bigint"), data_type: DataType::BigIntUnsigned(Some(20)), options: vec![], }, ], columns ); } _ => unreachable!(), } } #[test] fn parse_signed_data_types() { let sql = "CREATE TABLE foo (bar_tinyint TINYINT(3) SIGNED, bar_smallint SMALLINT(5) SIGNED, bar_mediumint MEDIUMINT(13) SIGNED, bar_int INT(11) SIGNED, bar_bigint BIGINT(20) SIGNED)"; let canonical = "CREATE TABLE foo (bar_tinyint TINYINT(3), bar_smallint SMALLINT(5), bar_mediumint MEDIUMINT(13), bar_int INT(11), bar_bigint BIGINT(20))"; match mysql().one_statement_parses_to(sql, canonical) { Statement::CreateTable(CreateTable { name, columns, .. }) => { assert_eq!(name.to_string(), "foo"); assert_eq!( vec![ ColumnDef { name: Ident::new("bar_tinyint"), data_type: DataType::TinyInt(Some(3)), options: vec![], }, ColumnDef { name: Ident::new("bar_smallint"), data_type: DataType::SmallInt(Some(5)), options: vec![], }, ColumnDef { name: Ident::new("bar_mediumint"), data_type: DataType::MediumInt(Some(13)), options: vec![], }, ColumnDef { name: Ident::new("bar_int"), data_type: DataType::Int(Some(11)), options: vec![], }, ColumnDef { name: Ident::new("bar_bigint"), data_type: DataType::BigInt(Some(20)), options: vec![], }, ], columns ); } _ => unreachable!(), } all_dialects_except(|d| d.supports_data_type_signed_suffix()) .run_parser_method(sql, |p| p.parse_statement()) .expect_err("SIGNED suffix should not be allowed"); } #[test] fn parse_deprecated_mysql_unsigned_data_types() { let sql = "CREATE TABLE foo (bar_decimal DECIMAL UNSIGNED, bar_decimal_prec DECIMAL(10) UNSIGNED, bar_decimal_scale DECIMAL(10,2) UNSIGNED, bar_dec DEC UNSIGNED, bar_dec_prec DEC(10) UNSIGNED, bar_dec_scale DEC(10,2) UNSIGNED, bar_float FLOAT UNSIGNED, bar_float_prec FLOAT(10) UNSIGNED, bar_float_scale FLOAT(10,2) UNSIGNED, bar_double DOUBLE UNSIGNED, bar_double_prec DOUBLE(10) UNSIGNED, bar_double_scale DOUBLE(10,2) UNSIGNED, bar_real REAL UNSIGNED, bar_double_precision DOUBLE PRECISION UNSIGNED)"; match mysql().verified_stmt(sql) { Statement::CreateTable(CreateTable { name, columns, .. }) => { assert_eq!(name.to_string(), "foo"); assert_eq!( vec![ ColumnDef { name: Ident::new("bar_decimal"), data_type: DataType::DecimalUnsigned(ExactNumberInfo::None), options: vec![], }, ColumnDef { name: Ident::new("bar_decimal_prec"), data_type: DataType::DecimalUnsigned(ExactNumberInfo::Precision(10)), options: vec![], }, ColumnDef { name: Ident::new("bar_decimal_scale"), data_type: DataType::DecimalUnsigned(ExactNumberInfo::PrecisionAndScale( 10, 2 )), options: vec![], }, ColumnDef { name: Ident::new("bar_dec"), data_type: DataType::DecUnsigned(ExactNumberInfo::None), options: vec![], }, ColumnDef { name: Ident::new("bar_dec_prec"), data_type: DataType::DecUnsigned(ExactNumberInfo::Precision(10)), options: vec![], }, ColumnDef { name: Ident::new("bar_dec_scale"), data_type: DataType::DecUnsigned(ExactNumberInfo::PrecisionAndScale(10, 2)), options: vec![], }, ColumnDef { name: Ident::new("bar_float"), data_type: DataType::FloatUnsigned(ExactNumberInfo::None), options: vec![], }, ColumnDef { name: Ident::new("bar_float_prec"), data_type: DataType::FloatUnsigned(ExactNumberInfo::Precision(10)), options: vec![], }, ColumnDef { name: Ident::new("bar_float_scale"), data_type: DataType::FloatUnsigned(ExactNumberInfo::PrecisionAndScale( 10, 2 )), options: vec![], }, ColumnDef { name: Ident::new("bar_double"), data_type: DataType::DoubleUnsigned(ExactNumberInfo::None), options: vec![], }, ColumnDef { name: Ident::new("bar_double_prec"), data_type: DataType::DoubleUnsigned(ExactNumberInfo::Precision(10)), options: vec![], }, ColumnDef { name: Ident::new("bar_double_scale"), data_type: DataType::DoubleUnsigned(ExactNumberInfo::PrecisionAndScale( 10, 2 )), options: vec![], }, ColumnDef { name: Ident::new("bar_real"), data_type: DataType::RealUnsigned, options: vec![], }, ColumnDef { name: Ident::new("bar_double_precision"), data_type: DataType::DoublePrecisionUnsigned, options: vec![], }, ], columns ); } _ => unreachable!(), } } #[test] fn parse_simple_insert() { let sql = r"INSERT INTO tasks (title, priority) VALUES ('Test Some Inserts', 1), ('Test Entry 2', 2), ('Test Entry 3', 3)"; match mysql().verified_stmt(sql) { Statement::Insert(Insert { table: table_name, columns, source, on, .. }) => { assert_eq!( TableObject::TableName(ObjectName::from(vec![Ident::new("tasks")])), table_name ); assert_eq!( vec![ ObjectName::from(Ident::new("title")), ObjectName::from(Ident::new("priority")) ], columns ); assert!(on.is_none()); assert_eq!( Some(Box::new(Query { with: None, body: Box::new(SetExpr::Values(Values { value_keyword: false, explicit_row: false, rows: vec![ Parens::with_empty_span(vec![ Expr::Value( (Value::SingleQuotedString("Test Some Inserts".to_string())) .with_empty_span() ), Expr::value(number("1")) ]), Parens::with_empty_span(vec![ Expr::Value( (Value::SingleQuotedString("Test Entry 2".to_string())) .with_empty_span() ), Expr::value(number("2")) ]), Parens::with_empty_span(vec![ Expr::Value( (Value::SingleQuotedString("Test Entry 3".to_string())) .with_empty_span() ), Expr::value(number("3")) ]) ] })), order_by: None, limit_clause: None, fetch: None, locks: vec![], for_clause: None, settings: None, format_clause: None, pipe_operators: vec![], })), source ); } _ => unreachable!(), } } #[test] fn parse_ignore_insert() { let sql = r"INSERT IGNORE INTO tasks (title, priority) VALUES ('Test Some Inserts', 1)"; match mysql_and_generic().verified_stmt(sql) { Statement::Insert(Insert { table: table_name, columns, source, on, ignore, .. }) => { assert_eq!( TableObject::TableName(ObjectName::from(vec![Ident::new("tasks")])), table_name ); assert_eq!( vec![ ObjectName::from(Ident::new("title")), ObjectName::from(Ident::new("priority")) ], columns ); assert!(on.is_none()); assert!(ignore); assert_eq!( Some(Box::new(Query { with: None, body: Box::new(SetExpr::Values(Values { value_keyword: false, explicit_row: false, rows: vec![Parens::with_empty_span(vec![ Expr::Value( (Value::SingleQuotedString("Test Some Inserts".to_string())) .with_empty_span() ), Expr::value(number("1")) ])] })), order_by: None, limit_clause: None, fetch: None, locks: vec![], for_clause: None, settings: None, format_clause: None, pipe_operators: vec![], })), source ); } _ => unreachable!(), } } #[test] fn parse_priority_insert() { let sql = r"INSERT HIGH_PRIORITY INTO tasks (title, priority) VALUES ('Test Some Inserts', 1)"; match mysql_and_generic().verified_stmt(sql) { Statement::Insert(Insert { table: table_name, columns, source, on, priority, .. }) => { assert_eq!( TableObject::TableName(ObjectName::from(vec![Ident::new("tasks")])), table_name ); assert_eq!( vec![ ObjectName::from(Ident::new("title")), ObjectName::from(Ident::new("priority")) ], columns ); assert!(on.is_none()); assert_eq!(priority, Some(HighPriority)); assert_eq!( Some(Box::new(Query { with: None, body: Box::new(SetExpr::Values(Values { value_keyword: false, explicit_row: false, rows: vec![Parens::with_empty_span(vec![ Expr::Value( (Value::SingleQuotedString("Test Some Inserts".to_string())) .with_empty_span() ), Expr::value(number("1")) ])] })), order_by: None, limit_clause: None, fetch: None, locks: vec![], for_clause: None, settings: None, format_clause: None, pipe_operators: vec![], })), source ); } _ => unreachable!(), } let sql2 = r"INSERT LOW_PRIORITY INTO tasks (title, priority) VALUES ('Test Some Inserts', 1)"; match mysql().verified_stmt(sql2) { Statement::Insert(Insert { table: table_name, columns, source, on, priority, .. }) => { assert_eq!( TableObject::TableName(ObjectName::from(vec![Ident::new("tasks")])), table_name ); assert_eq!( vec![ ObjectName::from(Ident::new("title")), ObjectName::from(Ident::new("priority")) ], columns ); assert!(on.is_none()); assert_eq!(priority, Some(LowPriority)); assert_eq!( Some(Box::new(Query { with: None, body: Box::new(SetExpr::Values(Values { value_keyword: false, explicit_row: false, rows: vec![Parens::with_empty_span(vec![ Expr::Value( (Value::SingleQuotedString("Test Some Inserts".to_string())) .with_empty_span() ), Expr::value(number("1")) ])] })), order_by: None, limit_clause: None, fetch: None, locks: vec![], for_clause: None, settings: None, format_clause: None, pipe_operators: vec![], })), source ); } _ => unreachable!(), } } #[test] fn parse_insert_as() { let sql = r"INSERT INTO `table` (`date`) VALUES ('2024-01-01') AS `alias`"; match mysql_and_generic().verified_stmt(sql) { Statement::Insert(Insert { table: table_name, columns, source, insert_alias, .. }) => { assert_eq!( TableObject::TableName(ObjectName::from(vec![Ident::with_quote('`', "table")])), table_name ); assert_eq!( vec![ObjectName::from(Ident::with_quote('`', "date"))], columns ); let insert_alias = insert_alias.unwrap(); assert_eq!( ObjectName::from(vec![Ident::with_quote('`', "alias")]), insert_alias.row_alias ); assert_eq!(Some(vec![]), insert_alias.col_aliases); assert_eq!( Some(Box::new(Query { with: None, body: Box::new(SetExpr::Values(Values { value_keyword: false, explicit_row: false, rows: vec![Parens::with_empty_span(vec![Expr::Value( (Value::SingleQuotedString("2024-01-01".to_string())).with_empty_span() )])] })), order_by: None, limit_clause: None, fetch: None, locks: vec![], for_clause: None, settings: None, format_clause: None, pipe_operators: vec![], })), source ); } _ => unreachable!(), } let sql = r"INSERT INTO `table` (`date`) VALUES ('2024-01-01') AS `alias` ()"; assert!(matches!( mysql_and_generic().parse_sql_statements(sql), Err(ParserError::ParserError(_)) )); let sql = r"INSERT INTO `table` (`id`, `date`) VALUES (1, '2024-01-01') AS `alias` (`mek_id`, `mek_date`)"; match mysql_and_generic().verified_stmt(sql) { Statement::Insert(Insert { table: table_name, columns, source, insert_alias, .. }) => { assert_eq!( TableObject::TableName(ObjectName::from(vec![Ident::with_quote('`', "table")])), table_name ); assert_eq!( vec![ ObjectName::from(Ident::with_quote('`', "id")), ObjectName::from(Ident::with_quote('`', "date")) ], columns ); let insert_alias = insert_alias.unwrap(); assert_eq!( ObjectName::from(vec![Ident::with_quote('`', "alias")]), insert_alias.row_alias ); assert_eq!( Some(vec![ Ident::with_quote('`', "mek_id"), Ident::with_quote('`', "mek_date") ]), insert_alias.col_aliases ); assert_eq!( Some(Box::new(Query { with: None, body: Box::new(SetExpr::Values(Values { value_keyword: false, explicit_row: false, rows: vec![Parens::with_empty_span(vec![ Expr::value(number("1")), Expr::Value( (Value::SingleQuotedString("2024-01-01".to_string())) .with_empty_span() ) ])] })), order_by: None, limit_clause: None, fetch: None, locks: vec![], for_clause: None, settings: None, format_clause: None, pipe_operators: vec![], })), source ); } _ => unreachable!(), } } #[test] fn parse_replace_insert() { let sql = r"REPLACE DELAYED INTO tasks (title, priority) VALUES ('Test Some Inserts', 1)"; match mysql().verified_stmt(sql) { Statement::Insert(Insert { table: table_name, columns, source, on, replace_into, priority, .. }) => { assert_eq!( TableObject::TableName(ObjectName::from(vec![Ident::new("tasks")])), table_name ); assert_eq!( vec![ ObjectName::from(Ident::new("title")), ObjectName::from(Ident::new("priority")) ], columns ); assert!(on.is_none()); assert!(replace_into); assert_eq!(priority, Some(Delayed)); assert_eq!( Some(Box::new(Query { with: None, body: Box::new(SetExpr::Values(Values { value_keyword: false, explicit_row: false, rows: vec![Parens::with_empty_span(vec![ Expr::Value( (Value::SingleQuotedString("Test Some Inserts".to_string())) .with_empty_span() ), Expr::value(number("1")) ])] })), order_by: None, limit_clause: None, fetch: None, locks: vec![], for_clause: None, settings: None, format_clause: None, pipe_operators: vec![], })), source ); } _ => unreachable!(), } } #[test] fn parse_empty_row_insert() { let sql = "INSERT INTO tb () VALUES (), ()"; match mysql().one_statement_parses_to(sql, "INSERT INTO tb VALUES (), ()") { Statement::Insert(Insert { table: table_name, columns, source, on, .. }) => { assert_eq!( TableObject::TableName(ObjectName::from(vec![Ident::new("tb")])), table_name ); assert!(columns.is_empty()); assert!(on.is_none()); assert_eq!( Some(Box::new(Query { with: None, body: Box::new(SetExpr::Values(Values { value_keyword: false, explicit_row: false, rows: vec![ Parens::with_empty_span(vec![]), Parens::with_empty_span(vec![]) ] })), order_by: None, limit_clause: None, fetch: None, locks: vec![], for_clause: None, settings: None, format_clause: None, pipe_operators: vec![], })), source ); } _ => unreachable!(), } } #[test] fn parse_insert_with_on_duplicate_update() { let sql = "INSERT INTO permission_groups (name, description, perm_create, perm_read, perm_update, perm_delete) VALUES ('accounting_manager', 'Some description about the group', true, true, true, true) ON DUPLICATE KEY UPDATE description = VALUES(description), perm_create = VALUES(perm_create), perm_read = VALUES(perm_read), perm_update = VALUES(perm_update), perm_delete = VALUES(perm_delete)"; match mysql().verified_stmt(sql) { Statement::Insert(Insert { table: table_name, columns, source, on, .. }) => { assert_eq!( TableObject::TableName(ObjectName::from(vec![Ident::new("permission_groups")])), table_name ); assert_eq!( vec![ ObjectName::from(Ident::new("name")), ObjectName::from(Ident::new("description")), ObjectName::from(Ident::new("perm_create")), ObjectName::from(Ident::new("perm_read")), ObjectName::from(Ident::new("perm_update")), ObjectName::from(Ident::new("perm_delete")) ], columns ); assert_eq!( Some(Box::new(Query { with: None, body: Box::new(SetExpr::Values(Values { value_keyword: false, explicit_row: false, rows: vec![Parens::with_empty_span(vec![ Expr::Value( (Value::SingleQuotedString("accounting_manager".to_string())) .with_empty_span() ), Expr::Value( (Value::SingleQuotedString( "Some description about the group".to_string() )) .with_empty_span() ), Expr::Value((Value::Boolean(true)).with_empty_span()), Expr::Value((Value::Boolean(true)).with_empty_span()), Expr::Value((Value::Boolean(true)).with_empty_span()), Expr::Value((Value::Boolean(true)).with_empty_span()), ])] })), order_by: None, limit_clause: None, fetch: None, locks: vec![], for_clause: None, settings: None, format_clause: None, pipe_operators: vec![], })), source ); assert_eq!( Some(OnInsert::DuplicateKeyUpdate(vec![ Assignment { target: AssignmentTarget::ColumnName(ObjectName::from(vec![Ident::new( "description".to_string() )])), value: call("VALUES", [Expr::Identifier(Ident::new("description"))]), }, Assignment { target: AssignmentTarget::ColumnName(ObjectName::from(vec![Ident::new( "perm_create".to_string() )])), value: call("VALUES", [Expr::Identifier(Ident::new("perm_create"))]), }, Assignment { target: AssignmentTarget::ColumnName(ObjectName::from(vec![Ident::new( "perm_read".to_string() )])), value: call("VALUES", [Expr::Identifier(Ident::new("perm_read"))]), }, Assignment { target: AssignmentTarget::ColumnName(ObjectName::from(vec![Ident::new( "perm_update".to_string() )])), value: call("VALUES", [Expr::Identifier(Ident::new("perm_update"))]), }, Assignment { target: AssignmentTarget::ColumnName(ObjectName::from(vec![Ident::new( "perm_delete".to_string() )])), value: call("VALUES", [Expr::Identifier(Ident::new("perm_delete"))]), }, ])), on ); } _ => unreachable!(), } } #[test] fn parse_select_with_numeric_prefix_column_name() { let sql = "SELECT 123col_$@123abc FROM \"table\""; match mysql().verified_stmt(sql) { Statement::Query(q) => { assert_eq!( q.body, Box::new(SetExpr::Select(Box::new(Select { select_token: AttachedToken::empty(), optimizer_hints: vec![], distinct: None, select_modifiers: None, top: None, top_before_distinct: false, projection: vec![SelectItem::UnnamedExpr(Expr::Identifier(Ident::new( "123col_$@123abc" )))], exclude: None, into: None, from: vec![TableWithJoins { relation: table_from_name(ObjectName::from(vec![Ident::with_quote( '"', "table" )])), joins: vec![] }], lateral_views: vec![], prewhere: None, selection: None, group_by: GroupByExpr::Expressions(vec![], vec![]), cluster_by: vec![], distribute_by: vec![], sort_by: vec![], having: None, named_window: vec![], qualify: None, window_before_qualify: false, value_table_mode: None, connect_by: vec![], flavor: SelectFlavor::Standard, }))) ); } _ => unreachable!(), } } #[test] fn parse_qualified_identifiers_with_numeric_prefix() { // Case 1: Qualified column name that starts with digits. match mysql().verified_stmt("SELECT t.15to29 FROM my_table AS t") { Statement::Query(q) => match *q.body { SetExpr::Select(s) => match s.projection.last() { Some(SelectItem::UnnamedExpr(Expr::CompoundIdentifier(parts))) => { assert_eq!(&[Ident::new("t"), Ident::new("15to29")], &parts[..]); } proj => panic!("Unexpected projection: {proj:?}"), }, body => panic!("Unexpected statement body: {body:?}"), }, stmt => panic!("Unexpected statement: {stmt:?}"), } // Case 2: Qualified column name that starts with digits and on its own represents a number. match mysql().verified_stmt("SELECT t.15e29 FROM my_table AS t") { Statement::Query(q) => match *q.body { SetExpr::Select(s) => match s.projection.last() { Some(SelectItem::UnnamedExpr(Expr::CompoundIdentifier(parts))) => { assert_eq!(&[Ident::new("t"), Ident::new("15e29")], &parts[..]); } proj => panic!("Unexpected projection: {proj:?}"), }, body => panic!("Unexpected statement body: {body:?}"), }, stmt => panic!("Unexpected statement: {stmt:?}"), } // Case 3: Unqualified, the same token is parsed as a number. match mysql() .parse_sql_statements("SELECT 15e29 FROM my_table") .unwrap() .pop() { Some(Statement::Query(q)) => match *q.body { SetExpr::Select(s) => match s.projection.last() { Some(SelectItem::UnnamedExpr(Expr::Value(ValueWithSpan { value, .. }))) => { assert_eq!(&number("15e29"), value); } proj => panic!("Unexpected projection: {proj:?}"), }, body => panic!("Unexpected statement body: {body:?}"), }, stmt => panic!("Unexpected statement: {stmt:?}"), } // Case 4: Quoted simple identifier. match mysql().verified_stmt("SELECT `15e29` FROM my_table") { Statement::Query(q) => match *q.body { SetExpr::Select(s) => match s.projection.last() { Some(SelectItem::UnnamedExpr(Expr::Identifier(name))) => { assert_eq!(&Ident::with_quote('`', "15e29"), name); } proj => panic!("Unexpected projection: {proj:?}"), }, body => panic!("Unexpected statement body: {body:?}"), }, stmt => panic!("Unexpected statement: {stmt:?}"), } // Case 5: Quoted compound identifier. match mysql().verified_stmt("SELECT t.`15e29` FROM my_table AS t") { Statement::Query(q) => match *q.body { SetExpr::Select(s) => match s.projection.last() { Some(SelectItem::UnnamedExpr(Expr::CompoundIdentifier(parts))) => { assert_eq!( &[Ident::new("t"), Ident::with_quote('`', "15e29")], &parts[..] ); } proj => panic!("Unexpected projection: {proj:?}"), }, body => panic!("Unexpected statement body: {body:?}"), }, stmt => panic!("Unexpected statement: {stmt:?}"), } // Case 6: Multi-level compound identifiers. match mysql().verified_stmt("SELECT 1db.1table.1column") { Statement::Query(q) => match *q.body { SetExpr::Select(s) => match s.projection.last() { Some(SelectItem::UnnamedExpr(Expr::CompoundIdentifier(parts))) => { assert_eq!( &[ Ident::new("1db"), Ident::new("1table"), Ident::new("1column") ], &parts[..] ); } proj => panic!("Unexpected projection: {proj:?}"), }, body => panic!("Unexpected statement body: {body:?}"), }, stmt => panic!("Unexpected statement: {stmt:?}"), } // Case 7: Multi-level compound quoted identifiers. match mysql().verified_stmt("SELECT `1`.`2`.`3`") { Statement::Query(q) => match *q.body { SetExpr::Select(s) => match s.projection.last() { Some(SelectItem::UnnamedExpr(Expr::CompoundIdentifier(parts))) => { assert_eq!( &[ Ident::with_quote('`', "1"), Ident::with_quote('`', "2"), Ident::with_quote('`', "3") ], &parts[..] ); } proj => panic!("Unexpected projection: {proj:?}"), }, body => panic!("Unexpected statement body: {body:?}"), }, stmt => panic!("Unexpected statement: {stmt:?}"), } } // Don't run with bigdecimal as it fails like this on rust beta: // // 'parse_select_with_concatenation_of_exp_number_and_numeric_prefix_column' // panicked at 'assertion failed: `(left == right)` // // left: `"SELECT 123e4, 123col_$@123abc FROM \"table\""`, // right: `"SELECT 1230000, 123col_$@123abc FROM \"table\""`', src/test_utils.rs:114:13 #[cfg(not(feature = "bigdecimal"))] #[test] fn parse_select_with_concatenation_of_exp_number_and_numeric_prefix_column() { let sql = "SELECT 123e4, 123col_$@123abc FROM \"table\""; match mysql().verified_stmt(sql) { Statement::Query(q) => { assert_eq!( q.body, Box::new(SetExpr::Select(Box::new(Select { select_token: AttachedToken::empty(), optimizer_hints: vec![], distinct: None, select_modifiers: None, top: None, top_before_distinct: false, projection: vec![ SelectItem::UnnamedExpr(Expr::value(number("123e4"))), SelectItem::UnnamedExpr(Expr::Identifier(Ident::new("123col_$@123abc"))) ], exclude: None, into: None, from: vec![TableWithJoins { relation: table_from_name(ObjectName::from(vec![Ident::with_quote( '"', "table" )])), joins: vec![] }], lateral_views: vec![], prewhere: None, selection: None, group_by: GroupByExpr::Expressions(vec![], vec![]), cluster_by: vec![], distribute_by: vec![], sort_by: vec![], having: None, named_window: vec![], qualify: None, window_before_qualify: false, value_table_mode: None, connect_by: vec![], flavor: SelectFlavor::Standard, }))) ); } _ => unreachable!(), } } #[test] fn parse_insert_with_numeric_prefix_column_name() { let sql = "INSERT INTO s1.t1 (123col_$@length123) VALUES (67.654)"; match mysql().verified_stmt(sql) { Statement::Insert(Insert { table: table_name, columns, .. }) => { assert_eq!( TableObject::TableName(ObjectName::from(vec![Ident::new("s1"), Ident::new("t1")])), table_name ); assert_eq!( vec![ObjectName::from(Ident::new("123col_$@length123"))], columns ); } _ => unreachable!(), } } #[test] fn parse_update_with_joins() { let sql = "UPDATE orders AS o JOIN customers AS c ON o.customer_id = c.id SET o.completed = true WHERE c.firstname = 'Peter'"; match mysql().verified_stmt(sql) { Statement::Update(Update { table, assignments, from: _from, selection, returning, or: None, order_by: _, limit: None, optimizer_hints, update_token: _, output: _, }) if optimizer_hints.is_empty() => { assert_eq!( TableWithJoins { relation: TableFactor::Table { name: ObjectName::from(vec![Ident::new("orders")]), alias: table_alias(true, "o"), args: None, with_hints: vec![], version: None, partitions: vec![], with_ordinality: false, json_path: None, sample: None, index_hints: vec![], }, joins: vec![Join { relation: TableFactor::Table { name: ObjectName::from(vec![Ident::new("customers")]), alias: table_alias(true, "c"), args: None, with_hints: vec![], version: None, partitions: vec![], with_ordinality: false, json_path: None, sample: None, index_hints: vec![], }, global: false, join_operator: JoinOperator::Join(JoinConstraint::On(Expr::BinaryOp { left: Box::new(Expr::CompoundIdentifier(vec![ Ident::new("o"), Ident::new("customer_id") ])), op: BinaryOperator::Eq, right: Box::new(Expr::CompoundIdentifier(vec![ Ident::new("c"), Ident::new("id") ])) })), }] }, table ); assert_eq!( vec![Assignment { target: AssignmentTarget::ColumnName(ObjectName::from(vec![ Ident::new("o"), Ident::new("completed") ])), value: Expr::Value((Value::Boolean(true)).with_empty_span()) }], assignments ); assert_eq!( Some(Expr::BinaryOp { left: Box::new(Expr::CompoundIdentifier(vec![ Ident::new("c"), Ident::new("firstname") ])), op: BinaryOperator::Eq, right: Box::new(Expr::Value( (Value::SingleQuotedString("Peter".to_string())).with_empty_span() )) }), selection ); assert_eq!(None, returning); } _ => unreachable!(), } } #[test] fn parse_update_with_order_by() { let sql = "UPDATE foo SET bar = false WHERE foo = true ORDER BY foo ASC"; match mysql_and_generic().verified_stmt(sql) { Statement::Update(Update { order_by, .. }) => { assert_eq!( vec![OrderByExpr { expr: Expr::Identifier(Ident { value: "foo".to_owned(), quote_style: None, span: Span::empty(), }), options: OrderByOptions { asc: Some(true), nulls_first: None, }, with_fill: None, }], order_by ); } _ => unreachable!(), } } #[test] fn parse_update_with_order_by_and_limit() { let sql = "UPDATE foo SET bar = false WHERE foo = true ORDER BY foo ASC LIMIT 10"; match mysql_and_generic().verified_stmt(sql) { Statement::Update(Update { order_by, limit, .. }) => { assert_eq!( vec![OrderByExpr { expr: Expr::Identifier(Ident { value: "foo".to_owned(), quote_style: None, span: Span::empty(), }), options: OrderByOptions { asc: Some(true), nulls_first: None, }, with_fill: None, }], order_by ); assert_eq!(Some(Expr::value(number("10"))), limit); } _ => unreachable!(), } } #[test] fn parse_delete_with_order_by() { let sql = "DELETE FROM customers ORDER BY id DESC"; match mysql().verified_stmt(sql) { Statement::Delete(Delete { order_by, .. }) => { assert_eq!( vec![OrderByExpr { expr: Expr::Identifier(Ident { value: "id".to_owned(), quote_style: None, span: Span::empty(), }), options: OrderByOptions { asc: Some(false), nulls_first: None, }, with_fill: None, }], order_by ); } _ => unreachable!(), } } #[test] fn parse_delete_with_limit() { let sql = "DELETE FROM customers LIMIT 100"; match mysql().verified_stmt(sql) { Statement::Delete(Delete { limit, .. }) => { assert_eq!(Some(Expr::value(number("100"))), limit); } _ => unreachable!(), } } #[test] fn parse_alter_table_add_column() { match mysql().verified_stmt("ALTER TABLE tab ADD COLUMN b INT FIRST") { Statement::AlterTable(AlterTable { name, if_exists, only, operations, table_type, location: _, on_cluster: _, end_token: _, }) => { assert_eq!(name.to_string(), "tab"); assert!(!if_exists); assert_eq!(table_type, None); assert!(!only); assert_eq!( operations, vec![AlterTableOperation::AddColumn { column_keyword: true, if_not_exists: false, column_def: ColumnDef { name: "b".into(), data_type: DataType::Int(None), options: vec![], }, column_position: Some(MySQLColumnPosition::First), },] ); } _ => unreachable!(), } match mysql().verified_stmt("ALTER TABLE tab ADD COLUMN b INT AFTER foo") { Statement::AlterTable(AlterTable { name, if_exists, only, operations, .. }) => { assert_eq!(name.to_string(), "tab"); assert!(!if_exists); assert!(!only); assert_eq!( operations, vec![AlterTableOperation::AddColumn { column_keyword: true, if_not_exists: false, column_def: ColumnDef { name: "b".into(), data_type: DataType::Int(None), options: vec![], }, column_position: Some(MySQLColumnPosition::After(Ident { value: String::from("foo"), quote_style: None, span: Span::empty(), })), },] ); } _ => unreachable!(), } } #[test] fn parse_alter_table_add_columns() { match mysql() .verified_stmt("ALTER TABLE tab ADD COLUMN a TEXT FIRST, ADD COLUMN b INT AFTER foo") { Statement::AlterTable(AlterTable { name, if_exists, only, operations, .. }) => { assert_eq!(name.to_string(), "tab"); assert!(!if_exists); assert!(!only); assert_eq!( operations, vec![ AlterTableOperation::AddColumn { column_keyword: true, if_not_exists: false, column_def: ColumnDef { name: "a".into(), data_type: DataType::Text, options: vec![], }, column_position: Some(MySQLColumnPosition::First), }, AlterTableOperation::AddColumn { column_keyword: true, if_not_exists: false, column_def: ColumnDef { name: "b".into(), data_type: DataType::Int(None), options: vec![], }, column_position: Some(MySQLColumnPosition::After(Ident { value: String::from("foo"), quote_style: None, span: Span::empty(), })), }, ] ); } _ => unreachable!(), } } #[test] fn parse_alter_table_drop_primary_key() { assert_matches!( alter_table_op(mysql_and_generic().verified_stmt("ALTER TABLE tab DROP PRIMARY KEY")), AlterTableOperation::DropPrimaryKey { drop_behavior: None } ); } #[test] fn parse_alter_table_drop_foreign_key() { assert_matches!( alter_table_op( mysql_and_generic().verified_stmt("ALTER TABLE tab DROP FOREIGN KEY foo_ibfk_1") ), AlterTableOperation::DropForeignKey { name, .. } if name.value == "foo_ibfk_1" ); } #[test] fn parse_alter_table_change_column() { let expected_name = ObjectName::from(vec![Ident::new("orders")]); let expected_operation = AlterTableOperation::ChangeColumn { old_name: Ident::new("description"), new_name: Ident::new("desc"), data_type: DataType::Text, options: vec![ColumnOption::NotNull], column_position: None, }; let sql1 = "ALTER TABLE orders CHANGE COLUMN description desc TEXT NOT NULL"; let operation = alter_table_op_with_name(mysql().verified_stmt(sql1), &expected_name.to_string()); assert_eq!(expected_operation, operation); let sql2 = "ALTER TABLE orders CHANGE description desc TEXT NOT NULL"; let operation = alter_table_op_with_name( mysql().one_statement_parses_to(sql2, sql1), &expected_name.to_string(), ); assert_eq!(expected_operation, operation); let expected_operation = AlterTableOperation::ChangeColumn { old_name: Ident::new("description"), new_name: Ident::new("desc"), data_type: DataType::Text, options: vec![ColumnOption::NotNull], column_position: Some(MySQLColumnPosition::First), }; let sql3 = "ALTER TABLE orders CHANGE COLUMN description desc TEXT NOT NULL FIRST"; let operation = alter_table_op_with_name(mysql().verified_stmt(sql3), &expected_name.to_string()); assert_eq!(expected_operation, operation); let expected_operation = AlterTableOperation::ChangeColumn { old_name: Ident::new("description"), new_name: Ident::new("desc"), data_type: DataType::Text, options: vec![ColumnOption::NotNull], column_position: Some(MySQLColumnPosition::After(Ident { value: String::from("foo"), quote_style: None, span: Span::empty(), })), }; let sql4 = "ALTER TABLE orders CHANGE COLUMN description desc TEXT NOT NULL AFTER foo"; let operation = alter_table_op_with_name(mysql().verified_stmt(sql4), &expected_name.to_string()); assert_eq!(expected_operation, operation); } #[test] fn parse_alter_table_change_column_with_column_position() { let expected_name = ObjectName::from(vec![Ident::new("orders")]); let expected_operation_first = AlterTableOperation::ChangeColumn { old_name: Ident::new("description"), new_name: Ident::new("desc"), data_type: DataType::Text, options: vec![ColumnOption::NotNull], column_position: Some(MySQLColumnPosition::First), }; let sql1 = "ALTER TABLE orders CHANGE COLUMN description desc TEXT NOT NULL FIRST"; let operation = alter_table_op_with_name(mysql().verified_stmt(sql1), &expected_name.to_string()); assert_eq!(expected_operation_first, operation); let sql2 = "ALTER TABLE orders CHANGE description desc TEXT NOT NULL FIRST"; let operation = alter_table_op_with_name( mysql().one_statement_parses_to(sql2, sql1), &expected_name.to_string(), ); assert_eq!(expected_operation_first, operation); let expected_operation_after = AlterTableOperation::ChangeColumn { old_name: Ident::new("description"), new_name: Ident::new("desc"), data_type: DataType::Text, options: vec![ColumnOption::NotNull], column_position: Some(MySQLColumnPosition::After(Ident { value: String::from("total_count"), quote_style: None, span: Span::empty(), })), }; let sql1 = "ALTER TABLE orders CHANGE COLUMN description desc TEXT NOT NULL AFTER total_count"; let operation = alter_table_op_with_name(mysql().verified_stmt(sql1), &expected_name.to_string()); assert_eq!(expected_operation_after, operation); let sql2 = "ALTER TABLE orders CHANGE description desc TEXT NOT NULL AFTER total_count"; let operation = alter_table_op_with_name( mysql().one_statement_parses_to(sql2, sql1), &expected_name.to_string(), ); assert_eq!(expected_operation_after, operation); } #[test] fn parse_alter_table_modify_column() { let expected_name = ObjectName::from(vec![Ident::new("orders")]); let expected_operation = AlterTableOperation::ModifyColumn { col_name: Ident::new("description"), data_type: DataType::Text, options: vec![ColumnOption::NotNull], column_position: None, }; let sql1 = "ALTER TABLE orders MODIFY COLUMN description TEXT NOT NULL"; let operation = alter_table_op_with_name(mysql().verified_stmt(sql1), &expected_name.to_string()); assert_eq!(expected_operation, operation); let sql2 = "ALTER TABLE orders MODIFY description TEXT NOT NULL"; let operation = alter_table_op_with_name( mysql().one_statement_parses_to(sql2, sql1), &expected_name.to_string(), ); assert_eq!(expected_operation, operation); let expected_operation = AlterTableOperation::ModifyColumn { col_name: Ident::new("description"), data_type: DataType::Text, options: vec![ColumnOption::NotNull], column_position: Some(MySQLColumnPosition::First), }; let sql3 = "ALTER TABLE orders MODIFY COLUMN description TEXT NOT NULL FIRST"; let operation = alter_table_op_with_name(mysql().verified_stmt(sql3), &expected_name.to_string()); assert_eq!(expected_operation, operation); let expected_operation = AlterTableOperation::ModifyColumn { col_name: Ident::new("description"), data_type: DataType::Text, options: vec![ColumnOption::NotNull], column_position: Some(MySQLColumnPosition::After(Ident { value: String::from("foo"), quote_style: None, span: Span::empty(), })), }; let sql4 = "ALTER TABLE orders MODIFY COLUMN description TEXT NOT NULL AFTER foo"; let operation = alter_table_op_with_name(mysql().verified_stmt(sql4), &expected_name.to_string()); assert_eq!(expected_operation, operation); } #[test] fn parse_alter_table_with_algorithm() { let sql = "ALTER TABLE tab ALGORITHM = COPY"; let expected_operation = AlterTableOperation::Algorithm { equals: true, algorithm: AlterTableAlgorithm::Copy, }; let operation = alter_table_op(mysql_and_generic().verified_stmt(sql)); assert_eq!(expected_operation, operation); // Check order doesn't matter let sql = "ALTER TABLE users DROP COLUMN password_digest, ALGORITHM = COPY, RENAME COLUMN name TO username"; let stmt = mysql_and_generic().verified_stmt(sql); match stmt { Statement::AlterTable(AlterTable { operations, .. }) => { assert_eq!( operations, vec![ AlterTableOperation::DropColumn { has_column_keyword: true, column_names: vec![Ident::new("password_digest")], if_exists: false, drop_behavior: None, }, AlterTableOperation::Algorithm { equals: true, algorithm: AlterTableAlgorithm::Copy, }, AlterTableOperation::RenameColumn { old_column_name: Ident::new("name"), new_column_name: Ident::new("username") }, ] ) } _ => panic!("Unexpected statement {stmt}"), } mysql_and_generic().verified_stmt("ALTER TABLE `users` ALGORITHM DEFAULT"); mysql_and_generic().verified_stmt("ALTER TABLE `users` ALGORITHM INSTANT"); mysql_and_generic().verified_stmt("ALTER TABLE `users` ALGORITHM INPLACE"); mysql_and_generic().verified_stmt("ALTER TABLE `users` ALGORITHM COPY"); mysql_and_generic().verified_stmt("ALTER TABLE `users` ALGORITHM = DEFAULT"); mysql_and_generic().verified_stmt("ALTER TABLE `users` ALGORITHM = INSTANT"); mysql_and_generic().verified_stmt("ALTER TABLE `users` ALGORITHM = INPLACE"); mysql_and_generic().verified_stmt("ALTER TABLE `users` ALGORITHM = COPY"); } #[test] fn parse_alter_table_with_lock() { let sql = "ALTER TABLE tab LOCK = SHARED"; let expected_operation = AlterTableOperation::Lock { equals: true, lock: AlterTableLock::Shared, }; let operation = alter_table_op(mysql_and_generic().verified_stmt(sql)); assert_eq!(expected_operation, operation); let sql = "ALTER TABLE users DROP COLUMN password_digest, LOCK = EXCLUSIVE, RENAME COLUMN name TO username"; let stmt = mysql_and_generic().verified_stmt(sql); match stmt { Statement::AlterTable(AlterTable { operations, .. }) => { assert_eq!( operations, vec![ AlterTableOperation::DropColumn { has_column_keyword: true, column_names: vec![Ident::new("password_digest")], if_exists: false, drop_behavior: None, }, AlterTableOperation::Lock { equals: true, lock: AlterTableLock::Exclusive, }, AlterTableOperation::RenameColumn { old_column_name: Ident::new("name"), new_column_name: Ident::new("username") }, ] ) } _ => panic!("Unexpected statement {stmt}"), } mysql_and_generic().verified_stmt("ALTER TABLE `users` LOCK DEFAULT"); mysql_and_generic().verified_stmt("ALTER TABLE `users` LOCK SHARED"); mysql_and_generic().verified_stmt("ALTER TABLE `users` LOCK NONE"); mysql_and_generic().verified_stmt("ALTER TABLE `users` LOCK EXCLUSIVE"); mysql_and_generic().verified_stmt("ALTER TABLE `users` LOCK = DEFAULT"); mysql_and_generic().verified_stmt("ALTER TABLE `users` LOCK = SHARED"); mysql_and_generic().verified_stmt("ALTER TABLE `users` LOCK = NONE"); mysql_and_generic().verified_stmt("ALTER TABLE `users` LOCK = EXCLUSIVE"); } #[test] fn parse_alter_table_auto_increment() { let sql = "ALTER TABLE tab AUTO_INCREMENT = 42"; let expected_operation = AlterTableOperation::AutoIncrement { equals: true, value: number("42").with_empty_span(), }; let operation = alter_table_op(mysql().verified_stmt(sql)); assert_eq!(expected_operation, operation); mysql_and_generic().verified_stmt("ALTER TABLE `users` AUTO_INCREMENT 42"); } #[test] fn parse_alter_table_modify_column_with_column_position() { let expected_name = ObjectName::from(vec![Ident::new("orders")]); let expected_operation_first = AlterTableOperation::ModifyColumn { col_name: Ident::new("description"), data_type: DataType::Text, options: vec![ColumnOption::NotNull], column_position: Some(MySQLColumnPosition::First), }; let sql1 = "ALTER TABLE orders MODIFY COLUMN description TEXT NOT NULL FIRST"; let operation = alter_table_op_with_name(mysql().verified_stmt(sql1), &expected_name.to_string()); assert_eq!(expected_operation_first, operation); let sql2 = "ALTER TABLE orders MODIFY description TEXT NOT NULL FIRST"; let operation = alter_table_op_with_name( mysql().one_statement_parses_to(sql2, sql1), &expected_name.to_string(), ); assert_eq!(expected_operation_first, operation); let expected_operation_after = AlterTableOperation::ModifyColumn { col_name: Ident::new("description"), data_type: DataType::Text, options: vec![ColumnOption::NotNull], column_position: Some(MySQLColumnPosition::After(Ident { value: String::from("total_count"), quote_style: None, span: Span::empty(), })), }; let sql1 = "ALTER TABLE orders MODIFY COLUMN description TEXT NOT NULL AFTER total_count"; let operation = alter_table_op_with_name(mysql().verified_stmt(sql1), &expected_name.to_string()); assert_eq!(expected_operation_after, operation); let sql2 = "ALTER TABLE orders MODIFY description TEXT NOT NULL AFTER total_count"; let operation = alter_table_op_with_name( mysql().one_statement_parses_to(sql2, sql1), &expected_name.to_string(), ); assert_eq!(expected_operation_after, operation); } #[test] fn parse_substring_in_select() { use sqlparser::tokenizer::Span; let sql = "SELECT DISTINCT SUBSTRING(description, 0, 1) FROM test"; match mysql().one_statement_parses_to( sql, "SELECT DISTINCT SUBSTRING(description, 0, 1) FROM test", ) { Statement::Query(query) => { assert_eq!( Box::new(Query { with: None, body: Box::new(SetExpr::Select(Box::new(Select { select_token: AttachedToken::empty(), optimizer_hints: vec![], distinct: Some(Distinct::Distinct), select_modifiers: None, top: None, top_before_distinct: false, projection: vec![SelectItem::UnnamedExpr(Expr::Substring { expr: Box::new(Expr::Identifier(Ident { value: "description".to_string(), quote_style: None, span: Span::empty(), })), substring_from: Some(Box::new(Expr::Value( (number("0")).with_empty_span() ))), substring_for: Some(Box::new(Expr::Value( (number("1")).with_empty_span() ))), special: true, shorthand: false, })], exclude: None, into: None, from: vec![TableWithJoins { relation: table_from_name(ObjectName::from(vec![Ident { value: "test".to_string(), quote_style: None, span: Span::empty(), }])), joins: vec![] }], lateral_views: vec![], prewhere: None, selection: None, group_by: GroupByExpr::Expressions(vec![], vec![]), cluster_by: vec![], distribute_by: vec![], sort_by: vec![], having: None, named_window: vec![], window_before_qualify: false, qualify: None, value_table_mode: None, connect_by: vec![], flavor: SelectFlavor::Standard, }))), order_by: None, limit_clause: None, fetch: None, locks: vec![], for_clause: None, settings: None, format_clause: None, pipe_operators: vec![], }), query ); } _ => unreachable!(), } } #[test] fn parse_show_variables() { mysql_and_generic().verified_stmt("SHOW VARIABLES"); mysql_and_generic().verified_stmt("SHOW VARIABLES LIKE 'admin%'"); mysql_and_generic().verified_stmt("SHOW VARIABLES WHERE value = '3306'"); mysql_and_generic().verified_stmt("SHOW GLOBAL VARIABLES"); mysql_and_generic().verified_stmt("SHOW GLOBAL VARIABLES LIKE 'admin%'"); mysql_and_generic().verified_stmt("SHOW GLOBAL VARIABLES WHERE value = '3306'"); mysql_and_generic().verified_stmt("SHOW SESSION VARIABLES"); mysql_and_generic().verified_stmt("SHOW SESSION VARIABLES LIKE 'admin%'"); mysql_and_generic().verified_stmt("SHOW GLOBAL VARIABLES WHERE value = '3306'"); } #[test] fn parse_rlike_and_regexp() { for s in &[ "SELECT 1 WHERE 'a' RLIKE '^a$'", "SELECT 1 WHERE 'a' REGEXP '^a$'", "SELECT 1 WHERE 'a' NOT RLIKE '^a$'", "SELECT 1 WHERE 'a' NOT REGEXP '^a$'", ] { mysql_and_generic().verified_only_select(s); } } #[test] fn parse_like_with_escape() { // verify backslash is not stripped for escaped wildcards mysql().verified_only_select(r#"SELECT 'a\%c' LIKE 'a\%c'"#); mysql().verified_only_select(r#"SELECT 'a\_c' LIKE 'a\_c'"#); mysql().verified_only_select(r#"SELECT '%\_\%' LIKE '%\_\%'"#); mysql().verified_only_select(r#"SELECT '\_\%' LIKE CONCAT('\_', '\%')"#); mysql().verified_only_select(r#"SELECT 'a%c' LIKE 'a$%c' ESCAPE '$'"#); mysql().verified_only_select(r#"SELECT 'a_c' LIKE 'a#_c' ESCAPE '#'"#); } #[test] fn parse_kill() { let stmt = mysql_and_generic().verified_stmt("KILL CONNECTION 5"); assert_eq!( stmt, Statement::Kill { modifier: Some(KillType::Connection), id: 5, } ); let stmt = mysql_and_generic().verified_stmt("KILL QUERY 5"); assert_eq!( stmt, Statement::Kill { modifier: Some(KillType::Query), id: 5, } ); let stmt = mysql_and_generic().verified_stmt("KILL 5"); assert_eq!( stmt, Statement::Kill { modifier: None, id: 5, } ); } #[test] fn parse_table_column_option_on_update() { let sql1 = "CREATE TABLE foo (`modification_time` DATETIME ON UPDATE CURRENT_TIMESTAMP())"; match mysql().verified_stmt(sql1) { Statement::CreateTable(CreateTable { name, columns, .. }) => { assert_eq!(name.to_string(), "foo"); assert_eq!( vec![ColumnDef { name: Ident::with_quote('`', "modification_time"), data_type: DataType::Datetime(None), options: vec![ColumnOptionDef { name: None, option: ColumnOption::OnUpdate(call("CURRENT_TIMESTAMP", [])), },], }], columns ); } _ => unreachable!(), } } #[test] fn parse_set_names() { let stmt = mysql_and_generic().verified_stmt("SET NAMES utf8mb4"); assert_eq!( stmt, Statement::Set(Set::SetNames { charset_name: "utf8mb4".into(), collation_name: None, }) ); let stmt = mysql_and_generic().verified_stmt("SET NAMES utf8mb4 COLLATE bogus"); assert_eq!( stmt, Statement::Set(Set::SetNames { charset_name: "utf8mb4".into(), collation_name: Some("bogus".to_string()), }) ); let stmt = mysql_and_generic() .parse_sql_statements("set names utf8mb4 collate bogus") .unwrap(); assert_eq!( stmt, vec![Statement::Set(Set::SetNames { charset_name: "utf8mb4".into(), collation_name: Some("bogus".to_string()), })] ); let stmt = mysql_and_generic().verified_stmt("SET NAMES DEFAULT"); assert_eq!(stmt, Statement::Set(Set::SetNamesDefault {})); } #[test] fn parse_limit_my_sql_syntax() { mysql_and_generic().verified_stmt("SELECT id, fname, lname FROM customer LIMIT 10 OFFSET 5"); mysql_and_generic().verified_stmt("SELECT id, fname, lname FROM customer LIMIT 5, 10"); mysql_and_generic().verified_stmt("SELECT * FROM user LIMIT ? OFFSET ?"); } #[test] fn parse_create_table_with_index_definition() { mysql_and_generic().one_statement_parses_to( "CREATE TABLE tb (id INT, INDEX (id))", "CREATE TABLE tb (id INT, INDEX (id))", ); mysql_and_generic().one_statement_parses_to( "CREATE TABLE tb (id INT, index USING BTREE (id))", "CREATE TABLE tb (id INT, INDEX USING BTREE (id))", ); mysql_and_generic().one_statement_parses_to( "CREATE TABLE tb (id INT, KEY USING HASH (id))", "CREATE TABLE tb (id INT, KEY USING HASH (id))", ); mysql_and_generic().one_statement_parses_to( "CREATE TABLE tb (id INT, key index (id))", "CREATE TABLE tb (id INT, KEY index (id))", ); mysql_and_generic().one_statement_parses_to( "CREATE TABLE tb (id INT, INDEX 'index' (id))", "CREATE TABLE tb (id INT, INDEX 'index' (id))", ); mysql_and_generic().one_statement_parses_to( "CREATE TABLE tb (id INT, INDEX index USING BTREE (id))", "CREATE TABLE tb (id INT, INDEX index USING BTREE (id))", ); mysql_and_generic().one_statement_parses_to( "CREATE TABLE tb (id INT, INDEX index USING HASH (id))", "CREATE TABLE tb (id INT, INDEX index USING HASH (id))", ); mysql_and_generic().one_statement_parses_to( "CREATE TABLE tb (id INT, INDEX (c1, c2, c3, c4,c5))", "CREATE TABLE tb (id INT, INDEX (c1, c2, c3, c4, c5))", ); } #[test] fn parse_create_table_unallow_constraint_then_index() { let sql = "CREATE TABLE foo (bar INT, CONSTRAINT constr INDEX index (bar))"; assert!(mysql_and_generic().parse_sql_statements(sql).is_err()); let sql = "CREATE TABLE foo (bar INT, INDEX index (bar))"; assert!(mysql_and_generic().parse_sql_statements(sql).is_ok()); } #[test] fn parse_create_table_constraint_check_without_name() { let dialects = all_dialects_where(|d| d.supports_constraint_keyword_without_name()); dialects.one_statement_parses_to( "CREATE TABLE t (x INT, CONSTRAINT PRIMARY KEY (x))", "CREATE TABLE t (x INT, PRIMARY KEY (x))", ); dialects.one_statement_parses_to( "CREATE TABLE t (x INT, CONSTRAINT UNIQUE (x))", "CREATE TABLE t (x INT, UNIQUE (x))", ); dialects.one_statement_parses_to( "CREATE TABLE t (x INT, CONSTRAINT FOREIGN KEY (x) REFERENCES t2(id))", "CREATE TABLE t (x INT, FOREIGN KEY (x) REFERENCES t2(id))", ); dialects.one_statement_parses_to( "CREATE TABLE t (x INT, CONSTRAINT CHECK (x > 1))", "CREATE TABLE t (x INT, CHECK (x > 1))", ); } #[test] fn parse_create_table_with_fulltext_definition() { mysql_and_generic().verified_stmt("CREATE TABLE tb (id INT, FULLTEXT (id))"); mysql_and_generic().verified_stmt("CREATE TABLE tb (id INT, FULLTEXT INDEX (id))"); mysql_and_generic().verified_stmt("CREATE TABLE tb (id INT, FULLTEXT KEY (id))"); mysql_and_generic().verified_stmt("CREATE TABLE tb (id INT, FULLTEXT potato (id))"); mysql_and_generic().verified_stmt("CREATE TABLE tb (id INT, FULLTEXT INDEX potato (id))"); mysql_and_generic().verified_stmt("CREATE TABLE tb (id INT, FULLTEXT KEY potato (id))"); mysql_and_generic() .verified_stmt("CREATE TABLE tb (c1 INT, c2 INT, FULLTEXT KEY potato (c1, c2))"); } #[test] fn parse_create_table_with_spatial_definition() { mysql_and_generic().verified_stmt("CREATE TABLE tb (id INT, SPATIAL (id))"); mysql_and_generic().verified_stmt("CREATE TABLE tb (id INT, SPATIAL INDEX (id))"); mysql_and_generic().verified_stmt("CREATE TABLE tb (id INT, SPATIAL KEY (id))"); mysql_and_generic().verified_stmt("CREATE TABLE tb (id INT, SPATIAL potato (id))"); mysql_and_generic().verified_stmt("CREATE TABLE tb (id INT, SPATIAL INDEX potato (id))"); mysql_and_generic().verified_stmt("CREATE TABLE tb (id INT, SPATIAL KEY potato (id))"); mysql_and_generic() .verified_stmt("CREATE TABLE tb (c1 INT, c2 INT, SPATIAL KEY potato (c1, c2))"); } #[test] fn parse_fulltext_expression() { mysql_and_generic().verified_stmt("SELECT * FROM tb WHERE MATCH (c1) AGAINST ('string')"); mysql_and_generic().verified_stmt( "SELECT * FROM tb WHERE MATCH (c1) AGAINST ('string' IN NATURAL LANGUAGE MODE)", ); mysql_and_generic().verified_stmt("SELECT * FROM tb WHERE MATCH (c1) AGAINST ('string' IN NATURAL LANGUAGE MODE WITH QUERY EXPANSION)"); mysql_and_generic() .verified_stmt("SELECT * FROM tb WHERE MATCH (c1) AGAINST ('string' IN BOOLEAN MODE)"); mysql_and_generic() .verified_stmt("SELECT * FROM tb WHERE MATCH (c1) AGAINST ('string' WITH QUERY EXPANSION)"); mysql_and_generic() .verified_stmt("SELECT * FROM tb WHERE MATCH (c1, c2, c3) AGAINST ('string')"); mysql_and_generic().verified_stmt("SELECT * FROM tb WHERE MATCH (c1) AGAINST (123)"); mysql_and_generic().verified_stmt("SELECT * FROM tb WHERE MATCH (c1) AGAINST (NULL)"); mysql_and_generic().verified_stmt("SELECT COUNT(IF(MATCH (title, body) AGAINST ('database' IN NATURAL LANGUAGE MODE), 1, NULL)) AS count FROM articles"); } #[test] #[should_panic = "Expected: FULLTEXT or SPATIAL option without constraint name, found: cons"] fn parse_create_table_with_fulltext_definition_should_not_accept_constraint_name() { mysql_and_generic().verified_stmt("CREATE TABLE tb (c1 INT, CONSTRAINT cons FULLTEXT (c1))"); } #[test] fn parse_values() { mysql().verified_stmt("VALUES ROW(1, true, 'a')"); mysql().verified_stmt("SELECT a, c FROM (VALUES ROW(1, true, 'a'), ROW(2, false, 'b'), ROW(3, false, 'c')) AS t (a, b, c)"); } #[test] fn parse_hex_string_introducer() { assert_eq!( mysql().verified_stmt("SELECT _latin1 X'4D7953514C'"), Statement::Query(Box::new(Query { with: None, body: Box::new(SetExpr::Select(Box::new(Select { select_token: AttachedToken::empty(), optimizer_hints: vec![], distinct: None, select_modifiers: None, top: None, top_before_distinct: false, projection: vec![SelectItem::UnnamedExpr(Expr::Prefixed { prefix: Ident::from("_latin1"), value: Expr::Value( Value::HexStringLiteral("4D7953514C".to_string()).with_empty_span() ) .into(), })], exclude: None, from: vec![], lateral_views: vec![], prewhere: None, selection: None, group_by: GroupByExpr::Expressions(vec![], vec![]), cluster_by: vec![], distribute_by: vec![], sort_by: vec![], having: None, named_window: vec![], window_before_qualify: false, qualify: None, value_table_mode: None, into: None, connect_by: vec![], flavor: SelectFlavor::Standard, }))), order_by: None, limit_clause: None, fetch: None, locks: vec![], for_clause: None, settings: None, format_clause: None, pipe_operators: vec![], })) ) } #[test] fn parse_string_introducers() { mysql().verified_stmt("SELECT _binary 'abc'"); mysql().one_statement_parses_to("SELECT _utf8'abc'", "SELECT _utf8 'abc'"); mysql().one_statement_parses_to("SELECT _utf8mb4'abc'", "SELECT _utf8mb4 'abc'"); mysql().verified_stmt("SELECT _binary 'abc', _utf8mb4 'abc'"); } #[test] fn parse_div_infix() { mysql().verified_stmt(r#"SELECT 5 DIV 2"#); } #[test] fn parse_div_infix_propagates_parse_error() { let err = mysql() .parse_sql_statements("SELECT 5 DIV") .expect_err("expected an error"); assert_matches!(err, ParserError::ParserError(_)); } #[test] fn parse_drop_temporary_table() { let sql = "DROP TEMPORARY TABLE foo"; match mysql().verified_stmt(sql) { Statement::Drop { object_type, if_exists, names, cascade, purge: _, temporary, .. } => { assert!(!if_exists); assert_eq!(ObjectType::Table, object_type); assert_eq!( vec!["foo"], names.iter().map(ToString::to_string).collect::>() ); assert!(!cascade); assert!(temporary); } _ => unreachable!(), } } #[test] fn parse_convert_using() { // https://dev.mysql.com/doc/refman/8.0/en/cast-functions.html#function_convert // CONVERT(expr USING transcoding_name) mysql().verified_only_select("SELECT CONVERT('x' USING latin1)"); mysql().verified_only_select("SELECT CONVERT(my_column USING utf8mb4) FROM my_table"); // CONVERT(expr, type) mysql().verified_only_select("SELECT CONVERT('abc', CHAR(60))"); mysql().verified_only_select("SELECT CONVERT(123.456, DECIMAL(5,2))"); // with a type + a charset mysql().verified_only_select("SELECT CONVERT('test', CHAR CHARACTER SET utf8mb4)"); } #[test] fn parse_create_table_with_column_collate() { let sql = "CREATE TABLE tb (id TEXT CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci)"; match mysql().verified_stmt(sql) { Statement::CreateTable(CreateTable { name, columns, .. }) => { assert_eq!(name.to_string(), "tb"); assert_eq!( vec![ColumnDef { name: Ident::new("id"), data_type: DataType::Text, options: vec![ ColumnOptionDef { name: None, option: ColumnOption::CharacterSet(ObjectName::from(vec![Ident::new( "utf8mb4" )])) }, ColumnOptionDef { name: None, option: ColumnOption::Collation(ObjectName::from(vec![Ident::new( "utf8mb4_0900_ai_ci" )])) } ], },], columns ); } _ => unreachable!(), } } #[test] fn parse_lock_tables() { mysql().one_statement_parses_to( "LOCK TABLES trans t READ, customer WRITE", "LOCK TABLES trans AS t READ, customer WRITE", ); mysql().verified_stmt("LOCK TABLES trans AS t READ, customer WRITE"); mysql().verified_stmt("LOCK TABLES trans AS t READ LOCAL, customer WRITE"); mysql().verified_stmt("LOCK TABLES trans AS t READ, customer LOW_PRIORITY WRITE"); mysql().verified_stmt("UNLOCK TABLES"); } #[test] fn parse_json_table() { mysql().verified_only_select("SELECT * FROM JSON_TABLE('[[1, 2], [3, 4]]', '$[*]' COLUMNS(a INT PATH '$[0]', b INT PATH '$[1]')) AS t"); mysql().verified_only_select( r#"SELECT * FROM JSON_TABLE('["x", "y"]', '$[*]' COLUMNS(a VARCHAR(20) PATH '$')) AS t"#, ); // with a bound parameter mysql().verified_only_select( r#"SELECT * FROM JSON_TABLE(?, '$[*]' COLUMNS(a VARCHAR(20) PATH '$')) AS t"#, ); // quote escaping mysql().verified_only_select(r#"SELECT * FROM JSON_TABLE('{"''": [1,2,3]}', '$."''"[*]' COLUMNS(a VARCHAR(20) PATH '$')) AS t"#); // double quotes mysql().verified_only_select( r#"SELECT * FROM JSON_TABLE("[]", "$[*]" COLUMNS(a VARCHAR(20) PATH "$")) AS t"#, ); // exists mysql().verified_only_select(r#"SELECT * FROM JSON_TABLE('[{}, {"x":1}]', '$[*]' COLUMNS(x INT EXISTS PATH '$.x')) AS t"#); // error handling mysql().verified_only_select( r#"SELECT * FROM JSON_TABLE('[1,2]', '$[*]' COLUMNS(x INT PATH '$' ERROR ON ERROR)) AS t"#, ); mysql().verified_only_select( r#"SELECT * FROM JSON_TABLE('[1,2]', '$[*]' COLUMNS(x INT PATH '$' ERROR ON EMPTY)) AS t"#, ); mysql().verified_only_select(r#"SELECT * FROM JSON_TABLE('[1,2]', '$[*]' COLUMNS(x INT PATH '$' ERROR ON EMPTY DEFAULT '0' ON ERROR)) AS t"#); mysql().verified_only_select( r#"SELECT jt.* FROM JSON_TABLE('["Alice", "Bob", "Charlie"]', '$[*]' COLUMNS(row_num FOR ORDINALITY, name VARCHAR(50) PATH '$')) AS jt"#, ); mysql().verified_only_select( r#"SELECT * FROM JSON_TABLE('[ {"a": 1, "b": [11,111]}, {"a": 2, "b": [22,222]}, {"a":3}]', '$[*]' COLUMNS(a INT PATH '$.a', NESTED PATH '$.b[*]' COLUMNS (b INT PATH '$'))) AS jt"#, ); assert_eq!( mysql() .verified_only_select( r#"SELECT * FROM JSON_TABLE('[1,2]', '$[*]' COLUMNS(x INT PATH '$' DEFAULT '0' ON EMPTY NULL ON ERROR)) AS t"# ) .from[0] .relation, TableFactor::JsonTable { json_expr: Expr::Value((Value::SingleQuotedString("[1,2]".to_string())).with_empty_span()), json_path: Value::SingleQuotedString("$[*]".to_string()).with_empty_span(), columns: vec![ JsonTableColumn::Named(JsonTableNamedColumn { name: Ident::new("x"), r#type: DataType::Int(None), path: Value::SingleQuotedString("$".to_string()).with_empty_span(), exists: false, on_empty: Some(JsonTableColumnErrorHandling::Default(Value::SingleQuotedString("0".to_string()).with_empty_span())), on_error: Some(JsonTableColumnErrorHandling::Null), }), ], alias: table_alias(true, "t"), } ); } #[test] fn test_group_concat() { // examples taken from mysql docs // https://dev.mysql.com/doc/refman/8.0/en/aggregate-functions.html#function_group-concat mysql_and_generic().verified_expr("GROUP_CONCAT(DISTINCT test_score)"); mysql_and_generic().verified_expr("GROUP_CONCAT(test_score ORDER BY test_score)"); mysql_and_generic().verified_expr("GROUP_CONCAT(test_score SEPARATOR ' ')"); mysql_and_generic() .verified_expr("GROUP_CONCAT(DISTINCT test_score ORDER BY test_score DESC SEPARATOR ' ')"); } /// The XOR binary operator is only supported in MySQL #[test] fn parse_logical_xor() { let sql = "SELECT true XOR true, false XOR false, true XOR false, false XOR true"; let select = mysql_and_generic().verified_only_select(sql); assert_eq!( SelectItem::UnnamedExpr(Expr::BinaryOp { left: Box::new(Expr::Value((Value::Boolean(true)).with_empty_span())), op: BinaryOperator::Xor, right: Box::new(Expr::Value((Value::Boolean(true)).with_empty_span())), }), select.projection[0] ); assert_eq!( SelectItem::UnnamedExpr(Expr::BinaryOp { left: Box::new(Expr::Value((Value::Boolean(false)).with_empty_span())), op: BinaryOperator::Xor, right: Box::new(Expr::Value((Value::Boolean(false)).with_empty_span())), }), select.projection[1] ); assert_eq!( SelectItem::UnnamedExpr(Expr::BinaryOp { left: Box::new(Expr::Value((Value::Boolean(true)).with_empty_span())), op: BinaryOperator::Xor, right: Box::new(Expr::Value((Value::Boolean(false)).with_empty_span())), }), select.projection[2] ); assert_eq!( SelectItem::UnnamedExpr(Expr::BinaryOp { left: Box::new(Expr::Value((Value::Boolean(false)).with_empty_span())), op: BinaryOperator::Xor, right: Box::new(Expr::Value((Value::Boolean(true)).with_empty_span())), }), select.projection[3] ); } #[test] fn parse_bitstring_literal() { let select = mysql_and_generic().verified_only_select("SELECT B'111'"); assert_eq!( select.projection, vec![SelectItem::UnnamedExpr(Expr::Value( (Value::SingleQuotedByteStringLiteral("111".to_string())).with_empty_span() ))] ); } #[test] fn parse_grant() { let sql = "GRANT ALL ON *.* TO 'jeffrey'@'%'"; let stmt = mysql().verified_stmt(sql); if let Statement::Grant(Grant { privileges, objects, grantees, with_grant_option, as_grantor: _, granted_by, current_grants: _, }) = stmt { assert_eq!( privileges, Privileges::All { with_privileges_keyword: false } ); assert_eq!( objects, Some(GrantObjects::Tables(vec![ObjectName::from(vec![ "*".into(), "*".into() ])])) ); assert!(!with_grant_option); assert!(granted_by.is_none()); if let [Grantee { grantee_type: GranteesType::None, name: Some(GranteeName::UserHost { user, host }), }] = grantees.as_slice() { assert_eq!(user.value, "jeffrey"); assert_eq!(user.quote_style, Some('\'')); assert_eq!(host.value, "%"); assert_eq!(host.quote_style, Some('\'')); } else { unreachable!() } } else { unreachable!() } } #[test] fn parse_revoke() { let sql = "REVOKE ALL ON db1.* FROM 'jeffrey'@'%'"; let stmt = mysql_and_generic().verified_stmt(sql); if let Statement::Revoke(Revoke { privileges, objects, grantees, granted_by, cascade, }) = stmt { assert_eq!( privileges, Privileges::All { with_privileges_keyword: false } ); assert_eq!( objects, Some(GrantObjects::Tables(vec![ObjectName::from(vec![ "db1".into(), "*".into() ])])) ); if let [Grantee { grantee_type: GranteesType::None, name: Some(GranteeName::UserHost { user, host }), }] = grantees.as_slice() { assert_eq!(user.value, "jeffrey"); assert_eq!(user.quote_style, Some('\'')); assert_eq!(host.value, "%"); assert_eq!(host.quote_style, Some('\'')); } else { unreachable!() } assert!(granted_by.is_none()); assert!(cascade.is_none()); } else { unreachable!() } } #[test] fn parse_create_view_algorithm_param() { let sql = "CREATE ALGORITHM = MERGE VIEW foo AS SELECT 1"; let stmt = mysql().verified_stmt(sql); if let Statement::CreateView(CreateView { params: Some(CreateViewParams { algorithm, definer, security, }), .. }) = stmt { assert_eq!(algorithm, Some(CreateViewAlgorithm::Merge)); assert!(definer.is_none()); assert!(security.is_none()); } else { unreachable!() } mysql().verified_stmt("CREATE ALGORITHM = UNDEFINED VIEW foo AS SELECT 1"); mysql().verified_stmt("CREATE ALGORITHM = TEMPTABLE VIEW foo AS SELECT 1"); } #[test] fn parse_create_view_definer_param() { let sql = "CREATE DEFINER = 'jeffrey'@'localhost' VIEW foo AS SELECT 1"; let stmt = mysql().verified_stmt(sql); if let Statement::CreateView(CreateView { params: Some(CreateViewParams { algorithm, definer, security, }), .. }) = stmt { assert!(algorithm.is_none()); if let Some(GranteeName::UserHost { user, host }) = definer { assert_eq!(user.value, "jeffrey"); assert_eq!(user.quote_style, Some('\'')); assert_eq!(host.value, "localhost"); assert_eq!(host.quote_style, Some('\'')); } else { unreachable!() } assert!(security.is_none()); } else { unreachable!() } } #[test] fn parse_create_view_security_param() { let sql = "CREATE SQL SECURITY DEFINER VIEW foo AS SELECT 1"; let stmt = mysql().verified_stmt(sql); if let Statement::CreateView(CreateView { params: Some(CreateViewParams { algorithm, definer, security, }), .. }) = stmt { assert!(algorithm.is_none()); assert!(definer.is_none()); assert_eq!(security, Some(CreateViewSecurity::Definer)); } else { unreachable!() } mysql().verified_stmt("CREATE SQL SECURITY INVOKER VIEW foo AS SELECT 1"); } #[test] fn parse_create_view_multiple_params() { let sql = "CREATE ALGORITHM = UNDEFINED DEFINER = `root`@`%` SQL SECURITY INVOKER VIEW foo AS SELECT 1"; let stmt = mysql().verified_stmt(sql); if let Statement::CreateView(CreateView { params: Some(CreateViewParams { algorithm, definer, security, }), .. }) = stmt { assert_eq!(algorithm, Some(CreateViewAlgorithm::Undefined)); if let Some(GranteeName::UserHost { user, host }) = definer { assert_eq!(user.value, "root"); assert_eq!(user.quote_style, Some('`')); assert_eq!(host.value, "%"); assert_eq!(host.quote_style, Some('`')); } else { unreachable!() } assert_eq!(security, Some(CreateViewSecurity::Invoker)); } else { unreachable!() } } #[test] fn parse_longblob_type() { let sql = "CREATE TABLE foo (bar LONGBLOB)"; let stmt = mysql_and_generic().verified_stmt(sql); if let Statement::CreateTable(CreateTable { columns, .. }) = stmt { assert_eq!(columns.len(), 1); assert_eq!(columns[0].data_type, DataType::LongBlob); } else { unreachable!() } mysql_and_generic().verified_stmt("CREATE TABLE foo (bar TINYBLOB)"); mysql_and_generic().verified_stmt("CREATE TABLE foo (bar MEDIUMBLOB)"); mysql_and_generic().verified_stmt("CREATE TABLE foo (bar TINYTEXT)"); mysql_and_generic().verified_stmt("CREATE TABLE foo (bar MEDIUMTEXT)"); mysql_and_generic().verified_stmt("CREATE TABLE foo (bar LONGTEXT)"); } #[test] fn parse_begin_without_transaction() { mysql().verified_stmt("BEGIN"); } #[test] fn parse_geometric_types_srid_option() { mysql_and_generic().verified_stmt("CREATE TABLE t (a geometry SRID 4326)"); } #[test] fn parse_double_precision() { mysql().verified_stmt("CREATE TABLE foo (bar DOUBLE)"); mysql().verified_stmt("CREATE TABLE foo (bar DOUBLE(11,0))"); mysql().one_statement_parses_to( "CREATE TABLE foo (bar DOUBLE(11, 0))", "CREATE TABLE foo (bar DOUBLE(11,0))", ); } #[test] fn parse_looks_like_single_line_comment() { mysql().one_statement_parses_to( "UPDATE account SET balance=balance--1 WHERE account_id=5752", "UPDATE account SET balance = balance - -1 WHERE account_id = 5752", ); mysql().one_statement_parses_to( r#" UPDATE account SET balance=balance-- 1 WHERE account_id=5752 "#, "UPDATE account SET balance = balance WHERE account_id = 5752", ); } #[test] fn parse_create_trigger() { let sql_create_trigger = r#"CREATE TRIGGER emp_stamp BEFORE INSERT ON emp FOR EACH ROW EXECUTE FUNCTION emp_stamp()"#; let create_stmt = mysql().verified_stmt(sql_create_trigger); assert_eq!( create_stmt, Statement::CreateTrigger(CreateTrigger { or_alter: false, temporary: false, or_replace: false, is_constraint: false, name: ObjectName::from(vec![Ident::new("emp_stamp")]), period: Some(TriggerPeriod::Before), period_before_table: true, events: vec![TriggerEvent::Insert], table_name: ObjectName::from(vec![Ident::new("emp")]), referenced_table_name: None, referencing: vec![], trigger_object: Some(TriggerObjectKind::ForEach(TriggerObject::Row)), condition: None, exec_body: Some(TriggerExecBody { exec_type: TriggerExecBodyType::Function, func_desc: FunctionDesc { name: ObjectName::from(vec![Ident::new("emp_stamp")]), args: Some(vec![]), } }), statements_as: false, statements: None, characteristics: None, }) ); } #[test] fn parse_create_trigger_compound_statement() { mysql_and_generic().verified_stmt("CREATE TRIGGER mytrigger BEFORE INSERT ON mytable FOR EACH ROW BEGIN SET NEW.a = 1; SET NEW.b = 2; END"); mysql_and_generic().verified_stmt("CREATE TRIGGER tr AFTER INSERT ON t1 FOR EACH ROW BEGIN INSERT INTO t2 VALUES (NEW.id); END"); } #[test] fn parse_drop_trigger() { let sql_drop_trigger = "DROP TRIGGER emp_stamp;"; let drop_stmt = mysql().one_statement_parses_to(sql_drop_trigger, ""); assert_eq!( drop_stmt, Statement::DropTrigger(DropTrigger { if_exists: false, trigger_name: ObjectName::from(vec![Ident::new("emp_stamp")]), table_name: None, option: None, }) ); } #[test] fn parse_cast_integers() { mysql().verified_expr("CAST(foo AS UNSIGNED)"); mysql().verified_expr("CAST(foo AS SIGNED)"); mysql().verified_expr("CAST(foo AS UNSIGNED INTEGER)"); mysql().verified_expr("CAST(foo AS SIGNED INTEGER)"); mysql() .run_parser_method("CAST(foo AS UNSIGNED(3))", |p| p.parse_expr()) .expect_err("CAST doesn't allow display width"); mysql() .run_parser_method("CAST(foo AS UNSIGNED(3) INTEGER)", |p| p.parse_expr()) .expect_err("CAST doesn't allow display width"); mysql() .run_parser_method("CAST(foo AS UNSIGNED INTEGER(3))", |p| p.parse_expr()) .expect_err("CAST doesn't allow display width"); } #[test] fn parse_cast_array() { mysql().verified_expr("CAST(foo AS SIGNED ARRAY)"); mysql() .run_parser_method("CAST(foo AS ARRAY)", |p| p.parse_expr()) .expect_err("ARRAY alone is not a type"); } #[test] fn parse_match_against_with_alias() { let sql = "SELECT tbl.ProjectID FROM surveys.tbl1 AS tbl WHERE MATCH (tbl.ReferenceID) AGAINST ('AAA' IN BOOLEAN MODE)"; match mysql().verified_stmt(sql) { Statement::Query(query) => match *query.body { SetExpr::Select(select) => match select.selection { Some(Expr::MatchAgainst { columns, match_value, opt_search_modifier, }) => { assert_eq!( columns, vec![ObjectName::from(vec![ Ident::new("tbl"), Ident::new("ReferenceID") ])] ); assert_eq!( match_value, Value::SingleQuotedString("AAA".to_owned()).with_empty_span() ); assert_eq!(opt_search_modifier, Some(SearchModifier::InBooleanMode)); } _ => unreachable!(), }, _ => unreachable!(), }, _ => unreachable!(), } } #[test] fn test_variable_assignment_using_colon_equal() { let sql_select = "SELECT @price := price, @tax := price * 0.1 FROM products WHERE id = 1"; let stmt = mysql().verified_stmt(sql_select); match stmt { Statement::Query(query) => { let select = query.body.as_select().unwrap(); assert_eq!( select.projection, vec![ SelectItem::UnnamedExpr(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident { value: "@price".to_string(), quote_style: None, span: Span::empty(), })), op: BinaryOperator::Assignment, right: Box::new(Expr::Identifier(Ident { value: "price".to_string(), quote_style: None, span: Span::empty(), })), }), SelectItem::UnnamedExpr(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident { value: "@tax".to_string(), quote_style: None, span: Span::empty(), })), op: BinaryOperator::Assignment, right: Box::new(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident { value: "price".to_string(), quote_style: None, span: Span::empty(), })), op: BinaryOperator::Multiply, right: Box::new(Expr::Value( (test_utils::number("0.1")).with_empty_span() )), }), }), ] ); assert_eq!( select.selection, Some(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident { value: "id".to_string(), quote_style: None, span: Span::empty(), })), op: BinaryOperator::Eq, right: Box::new(Expr::Value((test_utils::number("1")).with_empty_span())), }) ); } _ => panic!("Unexpected statement {stmt}"), } let sql_update = "UPDATE products SET price = @new_price := price * 1.1 WHERE category = 'Books'"; let stmt = mysql().verified_stmt(sql_update); match stmt { Statement::Update(Update { assignments, .. }) => { assert_eq!( assignments, vec![Assignment { target: AssignmentTarget::ColumnName(ObjectName(vec![ ObjectNamePart::Identifier(Ident { value: "price".to_string(), quote_style: None, span: Span::empty(), }) ])), value: Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident { value: "@new_price".to_string(), quote_style: None, span: Span::empty(), })), op: BinaryOperator::Assignment, right: Box::new(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident { value: "price".to_string(), quote_style: None, span: Span::empty(), })), op: BinaryOperator::Multiply, right: Box::new(Expr::Value( (test_utils::number("1.1")).with_empty_span() )), }), }, }] ) } _ => panic!("Unexpected statement {stmt}"), } } #[test] fn parse_straight_join() { mysql().verified_stmt( "SELECT a.*, b.* FROM table_a AS a STRAIGHT_JOIN table_b AS b ON a.b_id = b.id", ); // Without table alias mysql() .verified_stmt("SELECT a.*, b.* FROM table_a STRAIGHT_JOIN table_b AS b ON a.b_id = b.id"); } #[test] fn parse_distinctrow_to_distinct() { mysql().one_statement_parses_to( "SELECT DISTINCTROW * FROM employees", "SELECT DISTINCT * FROM employees", ); mysql().one_statement_parses_to( "SELECT HIGH_PRIORITY DISTINCTROW * FROM employees", "SELECT DISTINCT HIGH_PRIORITY * FROM employees", ); } #[test] fn parse_select_straight_join() { let select = mysql().verified_only_select( "SELECT STRAIGHT_JOIN * FROM employees e JOIN dept_emp d ON e.emp_no = d.emp_no WHERE d.emp_no = 10001", ); assert!(select.select_modifiers.unwrap().straight_join); mysql().verified_stmt( "SELECT STRAIGHT_JOIN e.emp_no, d.dept_no FROM employees e JOIN dept_emp d ON e.emp_no = d.emp_no", ); mysql().verified_stmt("SELECT DISTINCT STRAIGHT_JOIN emp_no FROM employees"); let select = mysql().verified_only_select("SELECT * FROM employees"); assert!(select.select_modifiers.is_none()); } #[test] fn parse_select_modifiers() { let select = mysql().verified_only_select("SELECT HIGH_PRIORITY * FROM employees"); assert!(select.select_modifiers.as_ref().unwrap().high_priority); assert!(!select.select_modifiers.unwrap().straight_join); let select = mysql().verified_only_select("SELECT SQL_SMALL_RESULT * FROM employees"); assert!(select.select_modifiers.unwrap().sql_small_result); let select = mysql().verified_only_select("SELECT SQL_BIG_RESULT * FROM employees"); assert!(select.select_modifiers.unwrap().sql_big_result); let select = mysql().verified_only_select("SELECT SQL_BUFFER_RESULT * FROM employees"); assert!(select.select_modifiers.unwrap().sql_buffer_result); let select = mysql().verified_only_select("SELECT SQL_NO_CACHE * FROM employees"); assert!(select.select_modifiers.unwrap().sql_no_cache); let select = mysql().verified_only_select("SELECT SQL_CALC_FOUND_ROWS * FROM employees"); assert!(select.select_modifiers.unwrap().sql_calc_found_rows); let select = mysql().verified_only_select( "SELECT HIGH_PRIORITY STRAIGHT_JOIN SQL_SMALL_RESULT SQL_BIG_RESULT SQL_BUFFER_RESULT SQL_NO_CACHE SQL_CALC_FOUND_ROWS * FROM employees", ); assert!(select.select_modifiers.as_ref().unwrap().high_priority); assert!(select.select_modifiers.as_ref().unwrap().straight_join); assert!(select.select_modifiers.as_ref().unwrap().sql_small_result); assert!(select.select_modifiers.as_ref().unwrap().sql_big_result); assert!(select.select_modifiers.as_ref().unwrap().sql_buffer_result); assert!(select.select_modifiers.as_ref().unwrap().sql_no_cache); assert!(select.select_modifiers.unwrap().sql_calc_found_rows); mysql().verified_stmt("SELECT DISTINCT HIGH_PRIORITY emp_no FROM employees"); mysql().verified_stmt("SELECT DISTINCT SQL_CALC_FOUND_ROWS emp_no FROM employees"); mysql().verified_stmt("SELECT HIGH_PRIORITY STRAIGHT_JOIN e.emp_no, d.dept_no FROM employees e JOIN dept_emp d ON e.emp_no = d.emp_no"); } #[test] fn parse_select_modifiers_any_order() { mysql().one_statement_parses_to( "SELECT HIGH_PRIORITY DISTINCT * FROM employees", "SELECT DISTINCT HIGH_PRIORITY * FROM employees", ); mysql().one_statement_parses_to( "SELECT SQL_CALC_FOUND_ROWS DISTINCT HIGH_PRIORITY * FROM employees", "SELECT DISTINCT HIGH_PRIORITY SQL_CALC_FOUND_ROWS * FROM employees", ); mysql().one_statement_parses_to( "SELECT HIGH_PRIORITY DISTINCT SQL_SMALL_RESULT * FROM employees", "SELECT DISTINCT HIGH_PRIORITY SQL_SMALL_RESULT * FROM employees", ); mysql().one_statement_parses_to( "SELECT HIGH_PRIORITY DISTINCTROW * FROM employees", "SELECT DISTINCT HIGH_PRIORITY * FROM employees", ); mysql().verified_stmt("SELECT ALL * FROM employees"); mysql().verified_stmt("SELECT ALL HIGH_PRIORITY * FROM employees"); mysql().one_statement_parses_to( "SELECT HIGH_PRIORITY ALL * FROM employees", "SELECT ALL HIGH_PRIORITY * FROM employees", ); let select = mysql().verified_only_select_with_canonical( "SELECT HIGH_PRIORITY DISTINCT * FROM employees", "SELECT DISTINCT HIGH_PRIORITY * FROM employees", ); assert!(select.select_modifiers.unwrap().high_priority); assert!(matches!(select.distinct, Some(Distinct::Distinct))); let select = mysql().verified_only_select_with_canonical( "SELECT SQL_CALC_FOUND_ROWS ALL HIGH_PRIORITY * FROM employees", "SELECT ALL HIGH_PRIORITY SQL_CALC_FOUND_ROWS * FROM employees", ); assert!(select.select_modifiers.as_ref().unwrap().high_priority); assert!(select.select_modifiers.unwrap().sql_calc_found_rows); assert_eq!(select.distinct, Some(Distinct::All)) } #[test] fn parse_select_modifiers_can_be_repeated() { mysql().one_statement_parses_to( "SELECT HIGH_PRIORITY HIGH_PRIORITY * FROM employees", "SELECT HIGH_PRIORITY * FROM employees", ); mysql().one_statement_parses_to( "SELECT SQL_CALC_FOUND_ROWS SQL_CALC_FOUND_ROWS * FROM employees", "SELECT SQL_CALC_FOUND_ROWS * FROM employees", ); mysql().one_statement_parses_to( "SELECT STRAIGHT_JOIN STRAIGHT_JOIN * FROM employees", "SELECT STRAIGHT_JOIN * FROM employees", ); mysql().one_statement_parses_to( "SELECT SQL_NO_CACHE SQL_NO_CACHE * FROM employees", "SELECT SQL_NO_CACHE * FROM employees", ); mysql().one_statement_parses_to( "SELECT HIGH_PRIORITY DISTINCT HIGH_PRIORITY * FROM employees", "SELECT DISTINCT HIGH_PRIORITY * FROM employees", ); mysql().one_statement_parses_to( "SELECT SQL_CALC_FOUND_ROWS DISTINCT SQL_CALC_FOUND_ROWS * FROM employees", "SELECT DISTINCT SQL_CALC_FOUND_ROWS * FROM employees", ); } #[test] fn parse_select_modifiers_canonical_ordering() { mysql().one_statement_parses_to( "SELECT SQL_CALC_FOUND_ROWS SQL_NO_CACHE SQL_BUFFER_RESULT SQL_BIG_RESULT SQL_SMALL_RESULT STRAIGHT_JOIN HIGH_PRIORITY * FROM employees", "SELECT HIGH_PRIORITY STRAIGHT_JOIN SQL_SMALL_RESULT SQL_BIG_RESULT SQL_BUFFER_RESULT SQL_NO_CACHE SQL_CALC_FOUND_ROWS * FROM employees", ); mysql().one_statement_parses_to( "SELECT SQL_NO_CACHE DISTINCT SQL_CALC_FOUND_ROWS * FROM employees", "SELECT DISTINCT SQL_NO_CACHE SQL_CALC_FOUND_ROWS * FROM employees", ); mysql().one_statement_parses_to( "SELECT HIGH_PRIORITY STRAIGHT_JOIN DISTINCT SQL_SMALL_RESULT * FROM employees", "SELECT DISTINCT HIGH_PRIORITY STRAIGHT_JOIN SQL_SMALL_RESULT * FROM employees", ); mysql().one_statement_parses_to( "SELECT HIGH_PRIORITY ALL STRAIGHT_JOIN * FROM employees", "SELECT ALL HIGH_PRIORITY STRAIGHT_JOIN * FROM employees", ); } #[test] fn parse_select_modifiers_errors() { assert!(mysql() .parse_sql_statements("SELECT DISTINCT DISTINCT * FROM t") .is_err()); assert!(mysql() .parse_sql_statements("SELECT DISTINCTROW DISTINCTROW * FROM t") .is_err()); assert!(mysql() .parse_sql_statements("SELECT DISTINCT DISTINCTROW * FROM t") .is_err()); assert!(mysql() .parse_sql_statements("SELECT ALL DISTINCT * FROM t") .is_err()); assert!(mysql() .parse_sql_statements("SELECT DISTINCT ALL * FROM t") .is_err()); assert!(mysql() .parse_sql_statements("SELECT ALL DISTINCTROW * FROM t") .is_err()); assert!(mysql() .parse_sql_statements("SELECT ALL ALL * FROM t") .is_err()); } #[test] fn mysql_foreign_key_with_index_name() { mysql().verified_stmt( "CREATE TABLE orders (customer_id INT, INDEX idx_customer (customer_id), CONSTRAINT fk_customer FOREIGN KEY idx_customer (customer_id) REFERENCES customers(id))", ); } #[test] fn parse_drop_index() { let sql = "DROP INDEX idx_name ON table_name"; match mysql().verified_stmt(sql) { Statement::Drop { object_type, if_exists, names, cascade, restrict, purge, temporary, table, } => { assert!(!if_exists); assert_eq!(ObjectType::Index, object_type); assert_eq!( vec!["idx_name"], names.iter().map(ToString::to_string).collect::>() ); assert!(!cascade); assert!(!restrict); assert!(!purge); assert!(!temporary); assert!(table.is_some()); assert_eq!("table_name", table.unwrap().to_string()); } _ => unreachable!(), } } #[test] fn parse_alter_table_drop_index() { assert_matches!( alter_table_op( mysql_and_generic().verified_stmt("ALTER TABLE tab DROP INDEX idx_index") ), AlterTableOperation::DropIndex { name } if name.value == "idx_index" ); } #[test] fn parse_json_member_of() { mysql().verified_stmt(r#"SELECT 17 MEMBER OF('[23, "abc", 17, "ab", 10]')"#); let sql = r#"SELECT 'ab' MEMBER OF('[23, "abc", 17, "ab", 10]')"#; let stmt = mysql().verified_stmt(sql); match stmt { Statement::Query(query) => { let select = query.body.as_select().unwrap(); assert_eq!( select.projection, vec![SelectItem::UnnamedExpr(Expr::MemberOf(MemberOf { value: Box::new(Expr::Value( Value::SingleQuotedString("ab".to_string()).into() )), array: Box::new(Expr::Value( Value::SingleQuotedString(r#"[23, "abc", 17, "ab", 10]"#.to_string()) .into() )), }))] ); } _ => panic!("Unexpected statement {stmt}"), } } #[test] fn parse_show_charset() { let res = mysql().verified_stmt("SHOW CHARACTER SET"); assert_eq!( res, Statement::ShowCharset(ShowCharset { is_shorthand: false, filter: None }) ); mysql().verified_stmt("SHOW CHARACTER SET LIKE 'utf8mb4%'"); mysql().verified_stmt("SHOW CHARSET WHERE charset = 'utf8mb4%'"); mysql().verified_stmt("SHOW CHARSET LIKE 'utf8mb4%'"); } #[test] fn test_ddl_with_index_using() { let columns = "(name, age DESC)"; let using = "USING BTREE"; for sql in [ format!("CREATE INDEX idx_name ON test {using} {columns}"), format!("CREATE TABLE foo (name VARCHAR(255), age INT, KEY idx_name {using} {columns})"), format!("ALTER TABLE foo ADD KEY idx_name {using} {columns}"), format!("CREATE INDEX idx_name ON test{columns} {using}"), format!("CREATE TABLE foo (name VARCHAR(255), age INT, KEY idx_name {columns} {using})"), format!("ALTER TABLE foo ADD KEY idx_name {columns} {using}"), ] { mysql_and_generic().verified_stmt(&sql); } } #[test] fn test_create_index_options() { mysql_and_generic() .verified_stmt("CREATE INDEX idx_name ON t(c1, c2) USING HASH LOCK = SHARED"); mysql_and_generic() .verified_stmt("CREATE INDEX idx_name ON t(c1, c2) USING BTREE ALGORITHM = INPLACE"); mysql_and_generic().verified_stmt( "CREATE INDEX idx_name ON t(c1, c2) USING BTREE LOCK = EXCLUSIVE ALGORITHM = DEFAULT", ); } #[test] fn test_optimizer_hints() { let mysql_dialect = mysql_and_generic(); // ~ selects mysql_dialect.verified_stmt( "\ SELECT /*+ SET_VAR(optimizer_switch = 'mrr_cost_based=off') \ SET_VAR(max_heap_table_size = 1G) */ 1", ); mysql_dialect.verified_stmt( "\ SELECT /*+ SET_VAR(target_partitions=1) */ * FROM \ (SELECT /*+ SET_VAR(target_partitions=8) */ * FROM t1 LIMIT 1) AS dt", ); // ~ inserts / replace mysql_dialect.verified_stmt( "\ INSERT /*+ RESOURCE_GROUP(Batch) */ \ INTO t2 VALUES (2)", ); mysql_dialect.verified_stmt( "\ REPLACE /*+ foobar */ INTO test \ VALUES (1, 'Old', '2014-08-20 18:47:00')", ); // ~ updates mysql_dialect.verified_stmt( "\ UPDATE /*+ quux */ table_name \ SET column1 = 1 \ WHERE 1 = 1", ); // ~ deletes mysql_dialect.verified_stmt( "\ DELETE /*+ foobar */ FROM table_name", ); // prefixed hints: any alphanumeric prefix before `+` is captured let select = mysql_dialect.verified_only_select("SELECT /*abc+ text */ 1"); assert_eq!(select.optimizer_hints.len(), 1); assert_eq!(select.optimizer_hints[0].prefix, "abc"); assert_eq!(select.optimizer_hints[0].text, " text "); // multiple hints with different prefixes let select = mysql_dialect.verified_only_select("SELECT /*+ A */ /*x2+ B */ 1"); assert_eq!(select.optimizer_hints.len(), 2); assert_eq!(select.optimizer_hints[0].prefix, ""); assert_eq!(select.optimizer_hints[0].text, " A "); assert_eq!(select.optimizer_hints[1].prefix, "x2"); assert_eq!(select.optimizer_hints[1].text, " B "); // hints mixed with regular comments: regular comments are skipped let select = mysql_dialect.verified_only_select_with_canonical( "SELECT /*+ A */ /* Regular comment */ /*x2+ B */ 1", "SELECT /*+ A */ /*x2+ B */ 1", ); assert_eq!(select.optimizer_hints.len(), 2); assert_eq!(select.optimizer_hints[0].prefix, ""); assert_eq!(select.optimizer_hints[0].text, " A "); assert_eq!(select.optimizer_hints[1].prefix, "x2"); assert_eq!(select.optimizer_hints[1].text, " B "); // prefixed hints in INSERT/UPDATE/DELETE mysql_dialect.verified_stmt("INSERT /*abc+ append */ INTO t2 VALUES (2)"); mysql_dialect.verified_stmt("UPDATE /*abc+ PARALLEL */ table_name SET column1 = 1"); mysql_dialect.verified_stmt("DELETE /*abc+ ENABLE_DML */ FROM table_name"); } #[test] fn parse_create_database_with_charset() { // Test DEFAULT CHARACTER SET with = sign mysql_and_generic().verified_stmt("CREATE DATABASE mydb DEFAULT CHARACTER SET utf8mb4"); // Test DEFAULT CHARACTER SET without = sign (normalized form) mysql_and_generic().one_statement_parses_to( "CREATE DATABASE mydb DEFAULT CHARACTER SET = utf8mb4", "CREATE DATABASE mydb DEFAULT CHARACTER SET utf8mb4", ); // Test CHARACTER SET without DEFAULT mysql_and_generic().one_statement_parses_to( "CREATE DATABASE mydb CHARACTER SET utf8mb4", "CREATE DATABASE mydb DEFAULT CHARACTER SET utf8mb4", ); // Test CHARSET shorthand mysql_and_generic().one_statement_parses_to( "CREATE DATABASE mydb CHARSET utf8mb4", "CREATE DATABASE mydb DEFAULT CHARACTER SET utf8mb4", ); // Test DEFAULT CHARSET shorthand mysql_and_generic().one_statement_parses_to( "CREATE DATABASE mydb DEFAULT CHARSET utf8mb4", "CREATE DATABASE mydb DEFAULT CHARACTER SET utf8mb4", ); // Test DEFAULT COLLATE mysql_and_generic().verified_stmt("CREATE DATABASE mydb DEFAULT COLLATE utf8mb4_unicode_ci"); // Test COLLATE without DEFAULT mysql_and_generic().one_statement_parses_to( "CREATE DATABASE mydb COLLATE utf8mb4_unicode_ci", "CREATE DATABASE mydb DEFAULT COLLATE utf8mb4_unicode_ci", ); // Test both CHARACTER SET and COLLATE together mysql_and_generic().verified_stmt( "CREATE DATABASE mydb DEFAULT CHARACTER SET utf8mb4 DEFAULT COLLATE utf8mb4_unicode_ci", ); // Test IF NOT EXISTS with CHARACTER SET mysql_and_generic() .verified_stmt("CREATE DATABASE IF NOT EXISTS mydb DEFAULT CHARACTER SET utf16"); // Test the exact syntax from the issue mysql_and_generic().one_statement_parses_to( "CREATE DATABASE IF NOT EXISTS noria DEFAULT CHARACTER SET = utf16", "CREATE DATABASE IF NOT EXISTS noria DEFAULT CHARACTER SET utf16", ); } #[test] fn parse_create_database_with_charset_errors() { // Missing charset name after CHARACTER SET assert!(mysql_and_generic() .parse_sql_statements("CREATE DATABASE mydb DEFAULT CHARACTER SET") .is_err()); // Missing charset name after CHARSET assert!(mysql_and_generic() .parse_sql_statements("CREATE DATABASE mydb CHARSET") .is_err()); // Missing collation name after COLLATE assert!(mysql_and_generic() .parse_sql_statements("CREATE DATABASE mydb DEFAULT COLLATE") .is_err()); // Equals sign but no value assert!(mysql_and_generic() .parse_sql_statements("CREATE DATABASE mydb CHARACTER SET =") .is_err()); } #[test] fn parse_create_database_with_charset_option_ordering() { // MySQL allows COLLATE before CHARACTER SET - output is normalized to CHARACTER SET first // (matches MySQL's own SHOW CREATE DATABASE output order) mysql_and_generic().one_statement_parses_to( "CREATE DATABASE mydb DEFAULT COLLATE utf8mb4_unicode_ci DEFAULT CHARACTER SET utf8mb4", "CREATE DATABASE mydb DEFAULT CHARACTER SET utf8mb4 DEFAULT COLLATE utf8mb4_unicode_ci", ); // COLLATE first without DEFAULT keywords mysql_and_generic().one_statement_parses_to( "CREATE DATABASE mydb COLLATE utf8mb4_unicode_ci CHARACTER SET utf8mb4", "CREATE DATABASE mydb DEFAULT CHARACTER SET utf8mb4 DEFAULT COLLATE utf8mb4_unicode_ci", ); } #[test] fn parse_adjacent_string_literal_concatenation() { let sql = r#"SELECT 'M' "y" 'S' "q" 'l'"#; mysql().one_statement_parses_to(sql, r"SELECT 'MySql'"); } apache-datafusion-sqlparser-rs-0.62.0/tests/sqlparser_oracle.rs000066400000000000000000000452171517524037000246750ustar00rootroot00000000000000// 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. //! Test SQL syntax, specific to [sqlparser::dialect::OracleDialect]. #[cfg(test)] use pretty_assertions::assert_eq; use sqlparser::{ ast::{ BinaryOperator, Expr, Ident, Insert, ObjectName, Query, QuoteDelimitedString, SetExpr, Statement, TableAliasWithoutColumns, TableObject, Value, ValueWithSpan, }, dialect::OracleDialect, parser::ParserError, tokenizer::Span, }; use test_utils::{all_dialects_where, expr_from_projection, number, TestedDialects}; mod test_utils; fn oracle() -> TestedDialects { TestedDialects::new(vec![Box::new(OracleDialect)]) } /// Convenience constructor for [QuoteDelimitedstring]. fn quote_delimited_string( start_quote: char, value: &'static str, end_quote: char, ) -> QuoteDelimitedString { QuoteDelimitedString { start_quote, value: value.into(), end_quote, } } /// Oracle: `||` has a lower precedence than `*` and `/` #[test] fn muldiv_have_higher_precedence_than_strconcat() { // ............... A .. B ...... C .. D ........... let sql = "SELECT 3 / 5 || 'asdf' || 7 * 9 FROM dual"; let select = oracle().verified_only_select(sql); assert_eq!(1, select.projection.len()); assert_eq!( expr_from_projection(&select.projection[0]), // (C || D) &Expr::BinaryOp { // (A || B) left: Box::new(Expr::BinaryOp { // A left: Box::new(Expr::BinaryOp { left: Box::new(Expr::Value(number("3").into())), op: BinaryOperator::Divide, right: Box::new(Expr::Value(number("5").into())), }), op: BinaryOperator::StringConcat, right: Box::new(Expr::Value(ValueWithSpan { value: Value::SingleQuotedString("asdf".into()), span: Span::empty(), })), }), op: BinaryOperator::StringConcat, // D right: Box::new(Expr::BinaryOp { left: Box::new(Expr::Value(number("7").into())), op: BinaryOperator::Multiply, right: Box::new(Expr::Value(number("9").into())), }), } ); } /// Oracle: `+`, `-`, and `||` have the same precedence and parse from left-to-right #[test] fn plusminus_have_same_precedence_as_strconcat() { // ................ A .. B .... C .. D ............ let sql = "SELECT 3 + 5 || '.3' || 7 - 9 FROM dual"; let select = oracle().verified_only_select(sql); assert_eq!(1, select.projection.len()); assert_eq!( expr_from_projection(&select.projection[0]), // D &Expr::BinaryOp { left: Box::new(Expr::BinaryOp { // B left: Box::new(Expr::BinaryOp { // A left: Box::new(Expr::BinaryOp { left: Box::new(Expr::Value(number("3").into())), op: BinaryOperator::Plus, right: Box::new(Expr::Value(number("5").into())), }), op: BinaryOperator::StringConcat, right: Box::new(Expr::Value(ValueWithSpan { value: Value::SingleQuotedString(".3".into()), span: Span::empty(), })), }), op: BinaryOperator::StringConcat, right: Box::new(Expr::Value(number("7").into())), }), op: BinaryOperator::Minus, right: Box::new(Expr::Value(number("9").into())) } ); } #[test] fn parse_quote_delimited_string() { let dialect = all_dialects_where(|d| d.supports_quote_delimited_string()); let sql = "SELECT Q'.abc.', \ Q'Xab'cX', \ Q'|abc'''|', \ Q'{abc}d}', \ Q'[]abc[]', \ Q'', \ Q'<<', \ Q'('abc'('abc)', \ Q'(abc'def))', \ Q'(abc'def)))' \ FROM dual"; let select = dialect.verified_only_select(sql); assert_eq!(10, select.projection.len()); assert_eq!( &Expr::Value( Value::QuoteDelimitedStringLiteral(quote_delimited_string('.', "abc", '.')) .with_empty_span() ), expr_from_projection(&select.projection[0]) ); assert_eq!( &Expr::Value( (Value::QuoteDelimitedStringLiteral(quote_delimited_string('X', "ab'c", 'X'))) .with_empty_span() ), expr_from_projection(&select.projection[1]) ); assert_eq!( &Expr::Value( (Value::QuoteDelimitedStringLiteral(quote_delimited_string('|', "abc'''", '|'))) .with_empty_span() ), expr_from_projection(&select.projection[2]) ); assert_eq!( &Expr::Value( (Value::QuoteDelimitedStringLiteral(quote_delimited_string('{', "abc}d", '}'))) .with_empty_span() ), expr_from_projection(&select.projection[3]) ); assert_eq!( &Expr::Value( (Value::QuoteDelimitedStringLiteral(quote_delimited_string('[', "]abc[", ']'))) .with_empty_span() ), expr_from_projection(&select.projection[4]) ); assert_eq!( &Expr::Value( (Value::QuoteDelimitedStringLiteral(quote_delimited_string('<', "a'bc", '>'))) .with_empty_span() ), expr_from_projection(&select.projection[5]) ); assert_eq!( &Expr::Value( (Value::QuoteDelimitedStringLiteral(quote_delimited_string('<', "<'))) .with_empty_span() ), expr_from_projection(&select.projection[6]) ); assert_eq!( &Expr::Value( (Value::QuoteDelimitedStringLiteral(quote_delimited_string('(', "'abc'('abc", ')'))) .with_empty_span() ), expr_from_projection(&select.projection[7]) ); assert_eq!( &Expr::Value( (Value::QuoteDelimitedStringLiteral(quote_delimited_string('(', "abc'def)", ')'))) .with_empty_span() ), expr_from_projection(&select.projection[8]) ); assert_eq!( &Expr::Value( (Value::QuoteDelimitedStringLiteral(quote_delimited_string('(', "abc'def))", ')'))) .with_empty_span() ), expr_from_projection(&select.projection[9]) ); } #[test] fn parse_invalid_quote_delimited_strings() { let dialect = all_dialects_where(|d| d.supports_quote_delimited_string()); // invalid quote delimiter for q in [' ', '\t', '\r', '\n'] { assert_eq!( dialect.parse_sql_statements(&format!("SELECT Q'{q}abc{q}' FROM dual")), Err(ParserError::TokenizerError( "Invalid space, tab, newline, or EOF after 'Q'' at Line: 1, Column: 10".into() )), "with quote char {q:?}" ); } // invalid eof after quote assert_eq!( dialect.parse_sql_statements("SELECT Q'"), Err(ParserError::TokenizerError( "Invalid space, tab, newline, or EOF after 'Q'' at Line: 1, Column: 10".into() )), "with EOF quote char" ); // unterminated string assert_eq!( dialect.parse_sql_statements("SELECT Q'|asdfa...."), Err(ParserError::TokenizerError( "Unterminated string literal at Line: 1, Column: 9".into() )), "with EOF quote char" ); } #[test] fn parse_quote_delimited_string_lowercase() { let dialect = all_dialects_where(|d| d.supports_quote_delimited_string()); let sql = "select q'!a'b'c!d!' from dual"; let select = dialect.verified_only_select_with_canonical(sql, "SELECT Q'!a'b'c!d!' FROM dual"); assert_eq!(1, select.projection.len()); assert_eq!( &Expr::Value( Value::QuoteDelimitedStringLiteral(quote_delimited_string('!', "a'b'c!d", '!')) .with_empty_span() ), expr_from_projection(&select.projection[0]) ); } #[test] fn parse_quote_delimited_string_but_is_a_word() { let dialect = all_dialects_where(|d| d.supports_quote_delimited_string()); let sql = "SELECT q, quux, q.abc FROM dual q"; let select = dialect.verified_only_select(sql); assert_eq!(3, select.projection.len()); assert_eq!( &Expr::Identifier(Ident::with_span(Span::empty(), "q")), expr_from_projection(&select.projection[0]) ); assert_eq!( &Expr::Identifier(Ident::with_span(Span::empty(), "quux")), expr_from_projection(&select.projection[1]) ); assert_eq!( &Expr::CompoundIdentifier(vec![ Ident::with_span(Span::empty(), "q"), Ident::with_span(Span::empty(), "abc") ]), expr_from_projection(&select.projection[2]) ); } #[test] fn parse_national_quote_delimited_string() { let dialect = all_dialects_where(|d| d.supports_quote_delimited_string()); let sql = "SELECT NQ'.abc.' FROM dual"; let select = dialect.verified_only_select(sql); assert_eq!(1, select.projection.len()); assert_eq!( &Expr::Value( Value::NationalQuoteDelimitedStringLiteral(quote_delimited_string('.', "abc", '.')) .with_empty_span() ), expr_from_projection(&select.projection[0]) ); } #[test] fn parse_national_quote_delimited_string_lowercase() { let dialect = all_dialects_where(|d| d.supports_quote_delimited_string()); for prefix in ["nq", "Nq", "nQ", "NQ"] { let select = dialect.verified_only_select_with_canonical( &format!("select {prefix}'!a'b'c!d!' from dual"), "SELECT NQ'!a'b'c!d!' FROM dual", ); assert_eq!(1, select.projection.len()); assert_eq!( &Expr::Value( Value::NationalQuoteDelimitedStringLiteral(quote_delimited_string( '!', "a'b'c!d", '!' )) .with_empty_span() ), expr_from_projection(&select.projection[0]) ); } } #[test] fn parse_national_quote_delimited_string_but_is_a_word() { let dialect = all_dialects_where(|d| d.supports_quote_delimited_string()); let sql = "SELECT nq, nqoo, nq.abc FROM dual q"; let select = dialect.verified_only_select(sql); assert_eq!(3, select.projection.len()); assert_eq!( &Expr::Identifier(Ident::with_span(Span::empty(), "nq")), expr_from_projection(&select.projection[0]) ); assert_eq!( &Expr::Identifier(Ident::with_span(Span::empty(), "nqoo")), expr_from_projection(&select.projection[1]) ); assert_eq!( &Expr::CompoundIdentifier(vec![ Ident::with_span(Span::empty(), "nq"), Ident::with_span(Span::empty(), "abc") ]), expr_from_projection(&select.projection[2]) ); } #[test] fn test_optimizer_hints() { let oracle_dialect = oracle(); // selects: all `/*+...*/` comments are collected as hints let select = oracle_dialect.verified_only_select_with_canonical( "SELECT /*+one two three*/ /*+four five six*/ 1 FROM dual", "SELECT /*+one two three*/ /*+four five six*/ 1 FROM dual", ); assert_eq!(select.optimizer_hints.len(), 2); assert_eq!(select.optimizer_hints[0].text, "one two three"); assert_eq!(select.optimizer_hints[0].prefix, ""); assert_eq!(select.optimizer_hints[1].text, "four five six"); // regular comments are skipped, hints after them are still collected let select = oracle_dialect.verified_only_select_with_canonical( "SELECT /*one two three*/ /*+four five six*/ 1 FROM dual", "SELECT /*+four five six*/ 1 FROM dual", ); assert_eq!(select.optimizer_hints.len(), 1); assert_eq!(select.optimizer_hints[0].text, "four five six"); let select = oracle_dialect.verified_only_select_with_canonical( "SELECT --+ one two three /* asdf */\n 1 FROM dual", "SELECT --+ one two three /* asdf */\n 1 FROM dual", ); assert_eq!(select.optimizer_hints.len(), 1); assert_eq!( select.optimizer_hints[0].text, " one two three /* asdf */\n" ); assert_eq!(select.optimizer_hints[0].prefix, ""); // inserts oracle_dialect.verified_stmt("INSERT /*+ append */ INTO t1 SELECT * FROM all_objects"); // updates oracle_dialect.verified_stmt("UPDATE /*+ DISABLE_PARALLEL_DML */ table_name SET column1 = 1"); // deletes oracle_dialect.verified_stmt("DELETE --+ ENABLE_PARALLEL_DML\n FROM table_name"); // merges oracle_dialect.verified_stmt( "MERGE /*+ CLUSTERING */ INTO people_target pt \ USING people_source ps \ ON (pt.person_id = ps.person_id) \ WHEN NOT MATCHED THEN INSERT \ (pt.person_id, pt.first_name, pt.last_name, pt.title) \ VALUES (ps.person_id, ps.first_name, ps.last_name, ps.title)", ); // single-line prefixed hint (Oracle supports `--` without trailing whitespace) let select = oracle_dialect.verified_only_select_with_canonical( "SELECT --abc+ text\n 1 FROM dual", "SELECT --abc+ text\n 1 FROM dual", ); assert_eq!(select.optimizer_hints.len(), 1); assert_eq!(select.optimizer_hints[0].prefix, "abc"); assert_eq!(select.optimizer_hints[0].text, " text\n"); } #[test] fn test_connect_by() { let oracle_dialect = oracle(); oracle_dialect.verified_only_select( "SELECT last_name AS \"Employee\", CONNECT_BY_ISCYCLE AS \"Cycle\", \ LEVEL, \ SYS_CONNECT_BY_PATH(last_name, '/') AS \"Path\" \ FROM employees \ WHERE level <= 3 AND department_id = 80 \ START WITH last_name = 'King' \ CONNECT BY NOCYCLE PRIOR employee_id = manager_id AND LEVEL <= 4 \ ORDER BY \"Employee\", \"Cycle\", LEVEL, \"Path\"", ); // CONNECT_BY_ROOT oracle_dialect.verified_only_select( "SELECT last_name AS \"Employee\", CONNECT_BY_ROOT last_name AS \"Manager\", \ LEVEL - 1 AS \"Pathlen\", SYS_CONNECT_BY_PATH(last_name, '/') AS \"Path\" \ FROM employees \ WHERE LEVEL > 1 AND department_id = 110 \ CONNECT BY PRIOR employee_id = manager_id \ ORDER BY \"Employee\", \"Manager\", \"Pathlen\", \"Path\"", ); } #[test] fn test_insert_with_table_alias() { let oracle_dialect = oracle(); fn verify_table_name_with_alias(stmt: &Statement, exp_table_name: &str, exp_table_alias: &str) { assert!(matches!(stmt, Statement::Insert(Insert { table: TableObject::TableName(table_name), table_alias: Some(TableAliasWithoutColumns { explicit: false, alias: Ident { value: table_alias, quote_style: None, span: _ } }), .. }) if table_alias == exp_table_alias && table_name == &ObjectName::from(vec![Ident { value: exp_table_name.into(), quote_style: None, span: Span::empty(), }]) )); } let stmt = oracle_dialect.verified_stmt( "INSERT INTO foo_t t \ SELECT 1, 2, 3 FROM dual", ); verify_table_name_with_alias(&stmt, "foo_t", "t"); let stmt = oracle_dialect.verified_stmt( "INSERT INTO foo_t asdf (a, b, c) \ SELECT 1, 2, 3 FROM dual", ); verify_table_name_with_alias(&stmt, "foo_t", "asdf"); let stmt = oracle_dialect.verified_stmt( "INSERT INTO foo_t t (a, b, c) \ VALUES (1, 2, 3)", ); verify_table_name_with_alias(&stmt, "foo_t", "t"); let stmt = oracle_dialect.verified_stmt( "INSERT INTO foo_t t \ VALUES (1, 2, 3)", ); verify_table_name_with_alias(&stmt, "foo_t", "t"); let stmt = oracle_dialect.verified_stmt("INSERT INTO foo_t t (t.id, t.val) SELECT 1, 2 FROM dual"); verify_table_name_with_alias(&stmt, "foo_t", "t"); if let Statement::Insert(Insert { columns, .. }) = stmt { assert_eq!( vec![ ObjectName::from(vec![Ident::new("t"), Ident::new("id")]), ObjectName::from(vec![Ident::new("t"), Ident::new("val")]) ], columns ); } else { panic!("not an insert statement"); }; } #[test] fn test_insert_without_alias() { let oracle_dialect = oracle(); // check DEFAULT let sql = "INSERT INTO t default SELECT 'a' FROM dual"; assert_eq!( oracle_dialect.parse_sql_statements(sql), Err(ParserError::ParserError( "Expected: SELECT, VALUES, or a subquery in the query body, found: default".into() )) ); // check SELECT let sql = "INSERT INTO t SELECT 'a' FROM dual"; let stmt = oracle_dialect.verified_stmt(sql); assert!(matches!( &stmt, Statement::Insert(Insert { table_alias: None, source: Some(source), .. }) if matches!(&**source, Query { body, .. } if matches!(&**body, SetExpr::Select(_))))); // check WITH let sql = "INSERT INTO dual WITH w AS (SELECT 1 AS y FROM dual) SELECT y FROM w"; let stmt = oracle_dialect.verified_stmt(sql); assert!(matches!( &stmt, Statement::Insert(Insert { table_alias: None, source: Some(source), .. }) if matches!(&**source, Query { body, .. } if matches!(&**body, SetExpr::Select(_))))); // check VALUES let sql = "INSERT INTO t VALUES (1)"; let stmt = oracle_dialect.verified_stmt(sql); assert!(matches!( stmt, Statement::Insert(Insert { table_alias: None, source: Some(source), .. }) if matches!(&*source, Query { body, .. } if matches!(&**body, SetExpr::Values(_))) )); } apache-datafusion-sqlparser-rs-0.62.0/tests/sqlparser_postgres.rs000066400000000000000000012117711517524037000252770ustar00rootroot00000000000000// 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. #![warn(clippy::all)] //! Test SQL syntax specific to PostgreSQL. The parser based on the //! generic dialect is also tested (on the inputs it can handle). #[macro_use] mod test_utils; use helpers::attached_token::AttachedToken; use sqlparser::ast::*; use sqlparser::dialect::{GenericDialect, PostgreSqlDialect}; use sqlparser::parser::ParserError; use sqlparser::tokenizer::Span; use test_utils::*; #[test] fn parse_create_table_generated_always_as_identity() { //With primary key let sql = "CREATE TABLE table2 ( column21 bigint primary key generated always as identity , column30 text );"; pg().one_statement_parses_to( sql, "CREATE TABLE table2 (\ column21 BIGINT PRIMARY KEY GENERATED ALWAYS AS IDENTITY, \ column30 TEXT)", ); let sql = "CREATE TABLE table2 ( column21 bigint primary key generated by default as identity , column30 text );"; pg().one_statement_parses_to( sql, "CREATE TABLE table2 (\ column21 BIGINT PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY, \ column30 TEXT)", ); //With out primary key let sql = "CREATE TABLE table2 ( column22 bigint generated always as identity , column30 text );"; pg().one_statement_parses_to( sql, "CREATE TABLE table2 (\ column22 BIGINT GENERATED ALWAYS AS IDENTITY, \ column30 TEXT)", ); let sql = "CREATE TABLE table2 ( column22 bigint generated by default as identity , column30 text );"; pg().one_statement_parses_to( sql, "CREATE TABLE table2 (\ column22 BIGINT GENERATED BY DEFAULT AS IDENTITY, \ column30 TEXT)", ); let sql = "CREATE TABLE table2 ( column23 bigint generated by default as identity ( INCREMENT 1 MINVALUE 1 MAXVALUE 20 START WITH 10 CACHE 2 NO CYCLE ), column30 text );"; pg().one_statement_parses_to( sql, "CREATE TABLE table2 (\ column23 BIGINT GENERATED BY DEFAULT AS IDENTITY ( INCREMENT 1 MINVALUE 1 MAXVALUE 20 START WITH 10 CACHE 2 NO CYCLE ), \ column30 TEXT)", ); let sql = "CREATE TABLE table2 ( column24 bigint generated by default as identity ( INCREMENT 1 MINVALUE 1 MAXVALUE 20 START WITH 10 CACHE 2 CYCLE ), column30 text );"; pg().one_statement_parses_to( sql, "CREATE TABLE table2 (\ column24 BIGINT GENERATED BY DEFAULT AS IDENTITY ( INCREMENT 1 MINVALUE 1 MAXVALUE 20 START WITH 10 CACHE 2 CYCLE ), \ column30 TEXT)", ); let sql = "CREATE TABLE table2 ( column25 bigint generated by default as identity ( INCREMENT 1 MINVALUE 1 MAXVALUE 20 START WITH 10 CACHE 2 ), column30 text );"; pg().one_statement_parses_to( sql, "CREATE TABLE table2 (\ column25 BIGINT GENERATED BY DEFAULT AS IDENTITY ( INCREMENT 1 MINVALUE 1 MAXVALUE 20 START WITH 10 CACHE 2 ), \ column30 TEXT)", ); let sql = "CREATE TABLE table2 ( column26 bigint generated by default as identity ( INCREMENT 1 MINVALUE 1 MAXVALUE 20 START WITH 10 ), column30 text );"; pg().one_statement_parses_to( sql, "CREATE TABLE table2 (\ column26 BIGINT GENERATED BY DEFAULT AS IDENTITY ( INCREMENT 1 MINVALUE 1 MAXVALUE 20 START WITH 10 ), \ column30 TEXT)", ); let sql = "CREATE TABLE table2 ( column27 bigint generated by default as identity ( INCREMENT 1 MINVALUE 1 MAXVALUE 20 ), column30 text );"; pg().one_statement_parses_to( sql, "CREATE TABLE table2 (\ column27 BIGINT GENERATED BY DEFAULT AS IDENTITY ( INCREMENT 1 MINVALUE 1 MAXVALUE 20 ), \ column30 TEXT)", ); let sql = "CREATE TABLE table2 ( column28 bigint generated by default as identity ( INCREMENT 1 MINVALUE 1 ), column30 text );"; pg().one_statement_parses_to( sql, "CREATE TABLE table2 (\ column28 BIGINT GENERATED BY DEFAULT AS IDENTITY ( INCREMENT 1 MINVALUE 1 ), \ column30 TEXT)", ); let sql = "CREATE TABLE table2 ( column29 bigint generated by default as identity ( INCREMENT 1 ), column30 text );"; pg().one_statement_parses_to( sql, "CREATE TABLE table2 (\ column29 BIGINT GENERATED BY DEFAULT AS IDENTITY ( INCREMENT 1 ), \ column30 TEXT)", ); let sql = "CREATE TABLE table2 ( column22 bigint generated always as identity , column30 text );"; pg().one_statement_parses_to( sql, "CREATE TABLE table2 (\ column22 BIGINT GENERATED ALWAYS AS IDENTITY, \ column30 TEXT)", ); let sql = "CREATE TABLE table2 ( column23 bigint generated always as identity ( INCREMENT 1 MINVALUE 1 MAXVALUE 20 START WITH 10 CACHE 2 NO CYCLE ), column30 text );"; pg().one_statement_parses_to( sql, "CREATE TABLE table2 (\ column23 BIGINT GENERATED ALWAYS AS IDENTITY ( INCREMENT 1 MINVALUE 1 MAXVALUE 20 START WITH 10 CACHE 2 NO CYCLE ), \ column30 TEXT)", ); let sql = "CREATE TABLE table2 ( column24 bigint generated always as identity ( INCREMENT 1 MINVALUE 1 MAXVALUE 20 START WITH 10 CACHE 2 CYCLE ), column30 text );"; pg().one_statement_parses_to( sql, "CREATE TABLE table2 (\ column24 BIGINT GENERATED ALWAYS AS IDENTITY ( INCREMENT 1 MINVALUE 1 MAXVALUE 20 START WITH 10 CACHE 2 CYCLE ), \ column30 TEXT)", ); let sql = "CREATE TABLE table2 ( column25 bigint generated always as identity ( INCREMENT 1 MINVALUE 1 MAXVALUE 20 START WITH 10 CACHE 2 ), column30 text );"; pg().one_statement_parses_to( sql, "CREATE TABLE table2 (\ column25 BIGINT GENERATED ALWAYS AS IDENTITY ( INCREMENT 1 MINVALUE 1 MAXVALUE 20 START WITH 10 CACHE 2 ), \ column30 TEXT)", ); let sql = "CREATE TABLE table2 ( column26 bigint generated always as identity ( INCREMENT 1 MINVALUE 1 MAXVALUE 20 START WITH 10 ), column30 text );"; pg().one_statement_parses_to( sql, "CREATE TABLE table2 (\ column26 BIGINT GENERATED ALWAYS AS IDENTITY ( INCREMENT 1 MINVALUE 1 MAXVALUE 20 START WITH 10 ), \ column30 TEXT)", ); let sql = "CREATE TABLE table2 ( column27 bigint generated always as identity ( INCREMENT 1 MINVALUE 1 MAXVALUE 20 ), column30 text );"; pg().one_statement_parses_to( sql, "CREATE TABLE table2 (\ column27 BIGINT GENERATED ALWAYS AS IDENTITY ( INCREMENT 1 MINVALUE 1 MAXVALUE 20 ), \ column30 TEXT)", ); let sql = "CREATE TABLE table2 ( column28 bigint generated always as identity ( INCREMENT 1 MINVALUE 1 ), column30 text );"; pg().one_statement_parses_to( sql, "CREATE TABLE table2 (\ column28 BIGINT GENERATED ALWAYS AS IDENTITY ( INCREMENT 1 MINVALUE 1 ), \ column30 TEXT)", ); let sql = "CREATE TABLE table2 ( column29 bigint generated always as identity ( INCREMENT 1 ), column30 text );"; pg().one_statement_parses_to( sql, "CREATE TABLE table2 (\ column29 BIGINT GENERATED ALWAYS AS IDENTITY ( INCREMENT 1 ), \ column30 TEXT)", ); let sql = "CREATE TABLE table2 ( priceInDollar numeric, princeInPound numeric GENERATED ALWAYS AS (priceInDollar * 0.22) STORED, column30 text );"; pg().one_statement_parses_to( sql, "CREATE TABLE table2 (\ priceInDollar NUMERIC, \ princeInPound NUMERIC GENERATED ALWAYS AS (priceInDollar * 0.22) STORED, \ column30 TEXT)", ); } #[test] fn parse_create_sequence() { // SimpleLogger::new().init().unwrap(); let sql1 = "CREATE SEQUENCE name0"; pg().one_statement_parses_to(sql1, "CREATE SEQUENCE name0"); let sql2 = "CREATE SEQUENCE IF NOT EXISTS name0"; pg().one_statement_parses_to(sql2, "CREATE SEQUENCE IF NOT EXISTS name0"); let sql3 = "CREATE TEMPORARY SEQUENCE IF NOT EXISTS name0"; pg().one_statement_parses_to(sql3, "CREATE TEMPORARY SEQUENCE IF NOT EXISTS name0"); let sql4 = "CREATE TEMPORARY SEQUENCE name0"; pg().one_statement_parses_to(sql4, "CREATE TEMPORARY SEQUENCE name0"); let sql2 = "CREATE TEMPORARY SEQUENCE IF NOT EXISTS name1 AS BIGINT INCREMENT BY 1 MINVALUE 1 MAXVALUE 20 START WITH 10"; pg().one_statement_parses_to( sql2, "CREATE TEMPORARY SEQUENCE IF NOT EXISTS name1 AS BIGINT INCREMENT BY 1 MINVALUE 1 MAXVALUE 20 START WITH 10", ); let sql3 = "CREATE SEQUENCE IF NOT EXISTS name2 AS BIGINT INCREMENT 1 MINVALUE 1 MAXVALUE 20 START WITH 10 CACHE 2 NO CYCLE"; pg().one_statement_parses_to( sql3, "CREATE SEQUENCE IF NOT EXISTS name2 AS BIGINT INCREMENT 1 MINVALUE 1 MAXVALUE 20 START WITH 10 CACHE 2 NO CYCLE", ); let sql4 = "CREATE TEMPORARY SEQUENCE IF NOT EXISTS name3 INCREMENT 1 NO MINVALUE MAXVALUE 20 CACHE 2 CYCLE"; pg().one_statement_parses_to( sql4, "CREATE TEMPORARY SEQUENCE IF NOT EXISTS name3 INCREMENT 1 NO MINVALUE MAXVALUE 20 CACHE 2 CYCLE", ); let sql5 = "CREATE TEMPORARY SEQUENCE IF NOT EXISTS name3 INCREMENT 1 NO MINVALUE MAXVALUE 20 OWNED BY public.table01"; pg().one_statement_parses_to( sql5, "CREATE TEMPORARY SEQUENCE IF NOT EXISTS name3 INCREMENT 1 NO MINVALUE MAXVALUE 20 OWNED BY public.table01", ); let sql6 = "CREATE TEMPORARY SEQUENCE IF NOT EXISTS name3 INCREMENT 1 NO MINVALUE MAXVALUE 20 OWNED BY NONE"; pg().one_statement_parses_to( sql6, "CREATE TEMPORARY SEQUENCE IF NOT EXISTS name3 INCREMENT 1 NO MINVALUE MAXVALUE 20 OWNED BY NONE", ); let sql7 = "CREATE SEQUENCE name4 AS BIGINT INCREMENT -15 MINVALUE - 2000 MAXVALUE -50 START WITH - 60"; pg().one_statement_parses_to( sql7, "CREATE SEQUENCE name4 AS BIGINT INCREMENT -15 MINVALUE -2000 MAXVALUE -50 START WITH -60", ); let sql8 = "CREATE SEQUENCE name5 AS BIGINT INCREMENT +10 MINVALUE + 30 MAXVALUE +5000 START WITH + 45"; pg().one_statement_parses_to( sql8, "CREATE SEQUENCE name5 AS BIGINT INCREMENT +10 MINVALUE +30 MAXVALUE +5000 START WITH +45", ); assert!(matches!( pg().parse_sql_statements("CREATE SEQUENCE foo INCREMENT 1 NO MINVALUE NO"), Err(ParserError::ParserError(_)) )); } #[test] fn parse_drop_sequence() { // SimpleLogger::new().init().unwrap(); let sql1 = "DROP SEQUENCE IF EXISTS name0 CASCADE"; pg().one_statement_parses_to(sql1, "DROP SEQUENCE IF EXISTS name0 CASCADE"); let sql2 = "DROP SEQUENCE IF EXISTS name1 RESTRICT"; pg().one_statement_parses_to(sql2, "DROP SEQUENCE IF EXISTS name1 RESTRICT"); let sql3 = "DROP SEQUENCE name2 CASCADE"; pg().one_statement_parses_to(sql3, "DROP SEQUENCE name2 CASCADE"); let sql4 = "DROP SEQUENCE name2"; pg().one_statement_parses_to(sql4, "DROP SEQUENCE name2"); let sql5 = "DROP SEQUENCE name0 CASCADE"; pg().one_statement_parses_to(sql5, "DROP SEQUENCE name0 CASCADE"); let sql6 = "DROP SEQUENCE name1 RESTRICT"; pg().one_statement_parses_to(sql6, "DROP SEQUENCE name1 RESTRICT"); let sql7 = "DROP SEQUENCE name1, name2, name3"; pg().one_statement_parses_to(sql7, "DROP SEQUENCE name1, name2, name3"); } #[test] fn parse_create_table_with_defaults() { let sql = "CREATE TABLE public.customer ( customer_id integer DEFAULT nextval(public.customer_customer_id_seq), store_id smallint NOT NULL, first_name character varying(45) NOT NULL, last_name character varying(45) COLLATE \"es_ES\" NOT NULL, email character varying(50), address_id smallint NOT NULL, activebool boolean DEFAULT true NOT NULL, create_date date DEFAULT now()::text NOT NULL, last_update timestamp without time zone DEFAULT now() NOT NULL, active int NOT NULL ) WITH (fillfactor = 20, user_catalog_table = true, autovacuum_vacuum_threshold = 100)"; match pg_and_generic().one_statement_parses_to(sql, "") { Statement::CreateTable(CreateTable { name, columns, constraints, table_options, if_not_exists: false, external: false, file_format: None, location: None, .. }) => { use pretty_assertions::assert_eq; assert_eq!("public.customer", name.to_string()); assert_eq!( columns, vec![ ColumnDef { name: "customer_id".into(), data_type: DataType::Integer(None), options: vec![ColumnOptionDef { name: None, option: ColumnOption::Default( pg().verified_expr("nextval(public.customer_customer_id_seq)") ) }], }, ColumnDef { name: "store_id".into(), data_type: DataType::SmallInt(None), options: vec![ColumnOptionDef { name: None, option: ColumnOption::NotNull, }], }, ColumnDef { name: "first_name".into(), data_type: DataType::CharacterVarying(Some( CharacterLength::IntegerLength { length: 45, unit: None } )), options: vec![ColumnOptionDef { name: None, option: ColumnOption::NotNull, }], }, ColumnDef { name: "last_name".into(), data_type: DataType::CharacterVarying(Some( CharacterLength::IntegerLength { length: 45, unit: None } )), options: vec![ ColumnOptionDef { name: None, option: ColumnOption::Collation(ObjectName::from(vec![ Ident::with_quote('"', "es_ES") ])), }, ColumnOptionDef { name: None, option: ColumnOption::NotNull, } ], }, ColumnDef { name: "email".into(), data_type: DataType::CharacterVarying(Some( CharacterLength::IntegerLength { length: 50, unit: None } )), options: vec![], }, ColumnDef { name: "address_id".into(), data_type: DataType::SmallInt(None), options: vec![ColumnOptionDef { name: None, option: ColumnOption::NotNull }], }, ColumnDef { name: "activebool".into(), data_type: DataType::Boolean, options: vec![ ColumnOptionDef { name: None, option: ColumnOption::Default(Expr::Value( (Value::Boolean(true)).with_empty_span() )), }, ColumnOptionDef { name: None, option: ColumnOption::NotNull, } ], }, ColumnDef { name: "create_date".into(), data_type: DataType::Date, options: vec![ ColumnOptionDef { name: None, option: ColumnOption::Default(pg().verified_expr("now()::TEXT")) }, ColumnOptionDef { name: None, option: ColumnOption::NotNull, } ], }, ColumnDef { name: "last_update".into(), data_type: DataType::Timestamp(None, TimezoneInfo::WithoutTimeZone), options: vec![ ColumnOptionDef { name: None, option: ColumnOption::Default(pg().verified_expr("now()")), }, ColumnOptionDef { name: None, option: ColumnOption::NotNull, } ], }, ColumnDef { name: "active".into(), data_type: DataType::Int(None), options: vec![ColumnOptionDef { name: None, option: ColumnOption::NotNull }], }, ] ); assert!(constraints.is_empty()); let with_options = match table_options { CreateTableOptions::With(options) => options, _ => unreachable!(), }; assert_eq!( with_options, vec![ SqlOption::KeyValue { key: "fillfactor".into(), value: Expr::value(number("20")) }, SqlOption::KeyValue { key: "user_catalog_table".into(), value: Expr::Value((Value::Boolean(true)).with_empty_span()) }, SqlOption::KeyValue { key: "autovacuum_vacuum_threshold".into(), value: Expr::value(number("100")) }, ] ); } _ => unreachable!(), } } #[test] fn parse_cast_in_default_expr() { pg().verified_stmt("CREATE TABLE t (c TEXT DEFAULT (foo())::TEXT)"); pg().verified_stmt("CREATE TABLE t (c TEXT DEFAULT (foo())::INT::TEXT)"); pg().verified_stmt("CREATE TABLE t (c TEXT DEFAULT (foo())::TEXT NOT NULL)"); } #[test] fn parse_create_table_from_pg_dump() { let sql = "CREATE TABLE public.customer ( customer_id integer DEFAULT nextval('public.customer_customer_id_seq'::regclass) NOT NULL, store_id smallint NOT NULL, first_name character varying(45) NOT NULL, last_name character varying(45) NOT NULL, info text[], address_id smallint NOT NULL, activebool boolean DEFAULT true NOT NULL, create_date date DEFAULT now()::DATE NOT NULL, create_date1 date DEFAULT 'now'::TEXT::date NOT NULL, last_update timestamp without time zone DEFAULT now(), release_year public.year, active int )"; pg().one_statement_parses_to(sql, "CREATE TABLE public.customer (\ customer_id INTEGER DEFAULT nextval('public.customer_customer_id_seq'::REGCLASS) NOT NULL, \ store_id SMALLINT NOT NULL, \ first_name CHARACTER VARYING(45) NOT NULL, \ last_name CHARACTER VARYING(45) NOT NULL, \ info TEXT[], \ address_id SMALLINT NOT NULL, \ activebool BOOLEAN DEFAULT true NOT NULL, \ create_date DATE DEFAULT now()::DATE NOT NULL, \ create_date1 DATE DEFAULT 'now'::TEXT::DATE NOT NULL, \ last_update TIMESTAMP WITHOUT TIME ZONE DEFAULT now(), \ release_year public.year, \ active INT\ )"); } #[test] fn parse_create_table_with_inherit() { let sql = "\ CREATE TABLE bazaar.settings (\ settings_id UUID PRIMARY KEY DEFAULT uuid_generate_v4() NOT NULL, \ user_id UUID UNIQUE, \ value TEXT[], \ use_metric BOOLEAN DEFAULT true\ )"; pg().verified_stmt(sql); } #[test] fn parse_create_table_empty() { // Zero-column tables are weird, but supported by at least PostgreSQL. // let _ = pg_and_generic().verified_stmt("CREATE TABLE t ()"); } #[test] fn parse_create_table_constraints_only() { // Zero-column tables can also have constraints in PostgreSQL let sql = "CREATE TABLE t (CONSTRAINT positive CHECK (2 > 1))"; let ast = pg_and_generic().verified_stmt(sql); match ast { Statement::CreateTable(CreateTable { name, columns, constraints, .. }) => { assert_eq!("t", name.to_string()); assert!(columns.is_empty()); assert_eq!( only(constraints).to_string(), "CONSTRAINT positive CHECK (2 > 1)" ); } _ => unreachable!(), }; } #[test] fn parse_create_table_like_with_defaults() { let sql = "CREATE TABLE new (LIKE old INCLUDING DEFAULTS)"; match pg().verified_stmt(sql) { Statement::CreateTable(stmt) => { assert_eq!( stmt.name, ObjectName::from(vec![Ident::new("new".to_string())]) ); assert_eq!( stmt.like, Some(CreateTableLikeKind::Parenthesized(CreateTableLike { name: ObjectName::from(vec![Ident::new("old".to_string())]), defaults: Some(CreateTableLikeDefaults::Including), })) ) } _ => unreachable!(), } let sql = "CREATE TABLE new (LIKE old EXCLUDING DEFAULTS)"; match pg().verified_stmt(sql) { Statement::CreateTable(stmt) => { assert_eq!( stmt.name, ObjectName::from(vec![Ident::new("new".to_string())]) ); assert_eq!( stmt.like, Some(CreateTableLikeKind::Parenthesized(CreateTableLike { name: ObjectName::from(vec![Ident::new("old".to_string())]), defaults: Some(CreateTableLikeDefaults::Excluding), })) ) } _ => unreachable!(), } } #[test] fn parse_alter_table_constraints_rename() { match alter_table_op( pg().verified_stmt("ALTER TABLE tab RENAME CONSTRAINT old_name TO new_name"), ) { AlterTableOperation::RenameConstraint { old_name, new_name } => { assert_eq!(old_name.to_string(), "old_name"); assert_eq!(new_name.to_string(), "new_name"); } _ => unreachable!(), } } #[test] fn parse_alter_table_constraints_unique_nulls_distinct() { match pg_and_generic() .verified_stmt("ALTER TABLE t ADD CONSTRAINT b UNIQUE NULLS NOT DISTINCT (c)") { Statement::AlterTable(alter_table) => match &alter_table.operations[0] { AlterTableOperation::AddConstraint { constraint: TableConstraint::Unique(constraint), .. } => { let nulls_distinct = &constraint.nulls_distinct; assert_eq!(nulls_distinct, &NullsDistinctOption::NotDistinct) } _ => unreachable!(), }, _ => unreachable!(), } pg_and_generic().verified_stmt("ALTER TABLE t ADD CONSTRAINT b UNIQUE NULLS DISTINCT (c)"); pg_and_generic().verified_stmt("ALTER TABLE t ADD CONSTRAINT b UNIQUE (c)"); } #[test] fn parse_alter_table_constraint_using_index() { // PRIMARY KEY USING INDEX // https://www.postgresql.org/docs/current/sql-altertable.html let sql = "ALTER TABLE tab ADD CONSTRAINT c PRIMARY KEY USING INDEX my_index"; match pg_and_generic().verified_stmt(sql) { Statement::AlterTable(alter_table) => match &alter_table.operations[0] { AlterTableOperation::AddConstraint { constraint: TableConstraint::PrimaryKeyUsingIndex(c), .. } => { assert_eq!(c.name.as_ref().unwrap().to_string(), "c"); assert_eq!(c.index_name.to_string(), "my_index"); assert!(c.characteristics.is_none()); } _ => unreachable!(), }, _ => unreachable!(), } // UNIQUE USING INDEX pg_and_generic().verified_stmt("ALTER TABLE tab ADD CONSTRAINT c UNIQUE USING INDEX my_index"); // Without constraint name pg_and_generic().verified_stmt("ALTER TABLE tab ADD PRIMARY KEY USING INDEX my_index"); pg_and_generic().verified_stmt("ALTER TABLE tab ADD UNIQUE USING INDEX my_index"); // With DEFERRABLE pg_and_generic().verified_stmt( "ALTER TABLE tab ADD CONSTRAINT c PRIMARY KEY USING INDEX my_index DEFERRABLE", ); pg_and_generic().verified_stmt( "ALTER TABLE tab ADD CONSTRAINT c UNIQUE USING INDEX my_index NOT DEFERRABLE INITIALLY IMMEDIATE", ); pg_and_generic().verified_stmt( "ALTER TABLE tab ADD CONSTRAINT c PRIMARY KEY USING INDEX my_index DEFERRABLE INITIALLY DEFERRED", ); } #[test] fn parse_alter_table_disable() { pg_and_generic().verified_stmt("ALTER TABLE tab DISABLE ROW LEVEL SECURITY"); pg_and_generic().verified_stmt("ALTER TABLE tab DISABLE RULE rule_name"); } #[test] fn parse_alter_table_disable_trigger() { pg_and_generic().verified_stmt("ALTER TABLE tab DISABLE TRIGGER ALL"); pg_and_generic().verified_stmt("ALTER TABLE tab DISABLE TRIGGER USER"); pg_and_generic().verified_stmt("ALTER TABLE tab DISABLE TRIGGER trigger_name"); } #[test] fn parse_alter_table_enable() { pg_and_generic().verified_stmt("ALTER TABLE tab ENABLE ALWAYS RULE rule_name"); pg_and_generic().verified_stmt("ALTER TABLE tab ENABLE ALWAYS TRIGGER trigger_name"); pg_and_generic().verified_stmt("ALTER TABLE tab ENABLE REPLICA TRIGGER trigger_name"); pg_and_generic().verified_stmt("ALTER TABLE tab ENABLE REPLICA RULE rule_name"); pg_and_generic().verified_stmt("ALTER TABLE tab ENABLE ROW LEVEL SECURITY"); pg_and_generic().verified_stmt("ALTER TABLE tab FORCE ROW LEVEL SECURITY"); pg_and_generic().verified_stmt("ALTER TABLE tab NO FORCE ROW LEVEL SECURITY"); pg_and_generic().verified_stmt("ALTER TABLE tab ENABLE RULE rule_name"); pg_and_generic().verified_stmt("ALTER TABLE tab ENABLE TRIGGER ALL"); pg_and_generic().verified_stmt("ALTER TABLE tab ENABLE TRIGGER USER"); pg_and_generic().verified_stmt("ALTER TABLE tab ENABLE TRIGGER trigger_name"); } #[test] fn parse_truncate_table() { pg_and_generic() .verified_stmt("TRUNCATE TABLE \"users\", \"orders\" RESTART IDENTITY RESTRICT"); pg_and_generic().verified_stmt("TRUNCATE users, orders RESTART IDENTITY"); } #[test] fn parse_create_extension() { pg_and_generic().verified_stmt("CREATE EXTENSION extension_name"); pg_and_generic().verified_stmt("CREATE EXTENSION extension_name WITH SCHEMA schema_name"); pg_and_generic().verified_stmt("CREATE EXTENSION extension_name WITH VERSION version"); pg_and_generic().verified_stmt("CREATE EXTENSION extension_name WITH CASCADE"); pg_and_generic().verified_stmt( "CREATE EXTENSION extension_name WITH SCHEMA schema_name VERSION version CASCADE", ); pg_and_generic() .verified_stmt("CREATE EXTENSION extension_name WITH SCHEMA schema_name CASCADE"); pg_and_generic().verified_stmt("CREATE EXTENSION extension_name WITH VERSION version CASCADE"); pg_and_generic() .verified_stmt("CREATE EXTENSION extension_name WITH SCHEMA schema_name VERSION version"); } #[test] fn parse_drop_extension() { assert_eq!( pg_and_generic().verified_stmt("DROP EXTENSION extension_name"), Statement::DropExtension(DropExtension { names: vec!["extension_name".into()], if_exists: false, cascade_or_restrict: None, }) ); assert_eq!( pg_and_generic().verified_stmt("DROP EXTENSION extension_name CASCADE"), Statement::DropExtension(DropExtension { names: vec!["extension_name".into()], if_exists: false, cascade_or_restrict: Some(ReferentialAction::Cascade), }) ); assert_eq!( pg_and_generic().verified_stmt("DROP EXTENSION extension_name RESTRICT"), Statement::DropExtension(DropExtension { names: vec!["extension_name".into()], if_exists: false, cascade_or_restrict: Some(ReferentialAction::Restrict), }) ); assert_eq!( pg_and_generic().verified_stmt("DROP EXTENSION extension_name, extension_name2 CASCADE"), Statement::DropExtension(DropExtension { names: vec!["extension_name".into(), "extension_name2".into()], if_exists: false, cascade_or_restrict: Some(ReferentialAction::Cascade), }) ); assert_eq!( pg_and_generic().verified_stmt("DROP EXTENSION extension_name, extension_name2 RESTRICT"), Statement::DropExtension(DropExtension { names: vec!["extension_name".into(), "extension_name2".into()], if_exists: false, cascade_or_restrict: Some(ReferentialAction::Restrict), }) ); assert_eq!( pg_and_generic().verified_stmt("DROP EXTENSION IF EXISTS extension_name"), Statement::DropExtension(DropExtension { names: vec!["extension_name".into()], if_exists: true, cascade_or_restrict: None, }) ); assert_eq!( pg_and_generic().verified_stmt("DROP EXTENSION IF EXISTS extension_name CASCADE"), Statement::DropExtension(DropExtension { names: vec!["extension_name".into()], if_exists: true, cascade_or_restrict: Some(ReferentialAction::Cascade), }) ); assert_eq!( pg_and_generic().verified_stmt("DROP EXTENSION IF EXISTS extension_name RESTRICT"), Statement::DropExtension(DropExtension { names: vec!["extension_name".into()], if_exists: true, cascade_or_restrict: Some(ReferentialAction::Restrict), }) ); assert_eq!( pg_and_generic() .verified_stmt("DROP EXTENSION IF EXISTS extension_name1, extension_name2 CASCADE"), Statement::DropExtension(DropExtension { names: vec!["extension_name1".into(), "extension_name2".into()], if_exists: true, cascade_or_restrict: Some(ReferentialAction::Cascade), }) ); assert_eq!( pg_and_generic() .verified_stmt("DROP EXTENSION IF EXISTS extension_name1, extension_name2 RESTRICT"), Statement::DropExtension(DropExtension { names: vec!["extension_name1".into(), "extension_name2".into()], if_exists: true, cascade_or_restrict: Some(ReferentialAction::Restrict), }) ); } #[test] fn parse_create_collation() { assert_eq!( pg_and_generic() .verified_stmt("CREATE COLLATION test3 (provider = icu, lc_collate = 'en_US.utf8')",), Statement::CreateCollation(CreateCollation { if_not_exists: false, name: ObjectName::from(vec![Ident::new("test3")]), definition: CreateCollationDefinition::Options(vec![ SqlOption::KeyValue { key: Ident::new("provider"), value: Expr::Identifier(Ident::new("icu")), }, SqlOption::KeyValue { key: Ident::new("lc_collate"), value: Expr::Value( Value::SingleQuotedString("en_US.utf8".to_string()).with_empty_span(), ), }, ]), }) ); assert_eq!( pg_and_generic().verified_stmt("CREATE COLLATION test4 FROM nonsense"), Statement::CreateCollation(CreateCollation { if_not_exists: false, name: ObjectName::from(vec![Ident::new("test4")]), definition: CreateCollationDefinition::From(ObjectName::from(vec![Ident::new( "nonsense", )])), }) ); assert_eq!( pg_and_generic() .verified_stmt("CREATE COLLATION testx (provider = icu, locale = 'nonsense-nowhere')"), Statement::CreateCollation(CreateCollation { if_not_exists: false, name: ObjectName::from(vec![Ident::new("testx")]), definition: CreateCollationDefinition::Options(vec![ SqlOption::KeyValue { key: Ident::new("provider"), value: Expr::Identifier(Ident::new("icu")), }, SqlOption::KeyValue { key: Ident::new("locale"), value: Expr::Value( Value::SingleQuotedString("nonsense-nowhere".to_string()).with_empty_span(), ), }, ]), }) ); } #[test] fn parse_alter_collation() { assert_eq!( pg_and_generic().verified_stmt("ALTER COLLATION test1 RENAME TO test11"), Statement::AlterCollation(AlterCollation { name: ObjectName::from(vec![Ident::new("test1")]), operation: AlterCollationOperation::RenameTo { new_name: Ident::new("test11"), }, }) ); assert_eq!( pg_and_generic().verified_stmt("ALTER COLLATION test11 OWNER TO regress_test_role"), Statement::AlterCollation(AlterCollation { name: ObjectName::from(vec![Ident::new("test11")]), operation: AlterCollationOperation::OwnerTo(Owner::Ident(Ident::new( "regress_test_role", ))), }) ); assert_eq!( pg_and_generic().verified_stmt("ALTER COLLATION test11 SET SCHEMA test_schema"), Statement::AlterCollation(AlterCollation { name: ObjectName::from(vec![Ident::new("test11")]), operation: AlterCollationOperation::SetSchema { schema_name: ObjectName::from(vec![Ident::new("test_schema")]), }, }) ); assert_eq!( pg_and_generic().verified_stmt("ALTER COLLATION \"en-x-icu\" REFRESH VERSION"), Statement::AlterCollation(AlterCollation { name: ObjectName::from(vec![Ident::with_quote('"', "en-x-icu")]), operation: AlterCollationOperation::RefreshVersion, }) ); } #[test] fn parse_drop_and_comment_collation_ast() { assert_eq!( pg_and_generic().verified_stmt("DROP COLLATION test0"), Statement::Drop { object_type: ObjectType::Collation, if_exists: false, names: vec![ObjectName::from(vec![Ident::new("test0")])], cascade: false, restrict: false, purge: false, temporary: false, table: None, } ); assert_eq!( pg_and_generic().verified_stmt("DROP COLLATION IF EXISTS test0"), Statement::Drop { object_type: ObjectType::Collation, if_exists: true, names: vec![ObjectName::from(vec![Ident::new("test0")])], cascade: false, restrict: false, purge: false, temporary: false, table: None, } ); assert_eq!( pg_and_generic().verified_stmt("COMMENT ON COLLATION test0 IS 'US English'"), Statement::Comment { object_type: CommentObject::Collation, object_name: ObjectName::from(vec![Ident::new("test0")]), comment: Some("US English".to_string()), if_exists: false, } ); } #[test] fn parse_collation_statements_roundtrip() { let statements = [ "CREATE COLLATION test3 (provider = icu, lc_collate = 'en_US.utf8')", "CREATE COLLATION testx (provider = icu, locale = 'nonsense-nowhere')", "CREATE COLLATION testx (provider = icu, locale = '@colStrength=primary;nonsense=yes')", "DROP COLLATION testx", "CREATE COLLATION test4 FROM nonsense", "CREATE COLLATION test5 FROM test0", "ALTER COLLATION test1 RENAME TO test11", "ALTER COLLATION test0 RENAME TO test11", "ALTER COLLATION test1 RENAME TO test22", "ALTER COLLATION test11 OWNER TO regress_test_role", "ALTER COLLATION test11 OWNER TO nonsense", "ALTER COLLATION test11 SET SCHEMA test_schema", "COMMENT ON COLLATION test0 IS 'US English'", "DROP COLLATION test0, test_schema.test11, test5", "DROP COLLATION test0", "DROP COLLATION IF EXISTS test0", "ALTER COLLATION \"en-x-icu\" REFRESH VERSION", ]; for sql in statements { pg_and_generic().verified_stmt(sql); } } #[test] fn parse_alter_table_alter_column() { pg().verified_stmt("ALTER TABLE tab ALTER COLUMN is_active TYPE TEXT USING 'text'"); match alter_table_op( pg().verified_stmt( "ALTER TABLE tab ALTER COLUMN is_active SET DATA TYPE TEXT USING 'text'", ), ) { AlterTableOperation::AlterColumn { column_name, op } => { assert_eq!("is_active", column_name.to_string()); let using_expr = Expr::Value(Value::SingleQuotedString("text".to_string()).with_empty_span()); assert_eq!( op, AlterColumnOperation::SetDataType { data_type: DataType::Text, using: Some(using_expr), had_set: true, } ); } _ => unreachable!(), } } #[test] fn parse_alter_table_alter_column_add_generated() { pg_and_generic() .verified_stmt("ALTER TABLE t ALTER COLUMN id ADD GENERATED ALWAYS AS IDENTITY"); pg_and_generic() .verified_stmt("ALTER TABLE t ALTER COLUMN id ADD GENERATED BY DEFAULT AS IDENTITY"); pg_and_generic().verified_stmt("ALTER TABLE t ALTER COLUMN id ADD GENERATED AS IDENTITY"); pg_and_generic().verified_stmt( "ALTER TABLE t ALTER COLUMN id ADD GENERATED AS IDENTITY ( INCREMENT 1 MINVALUE 1 )", ); pg_and_generic().verified_stmt("ALTER TABLE t ALTER COLUMN id ADD GENERATED AS IDENTITY ( )"); let res = pg().parse_sql_statements( "ALTER TABLE t ALTER COLUMN id ADD GENERATED ( INCREMENT 1 MINVALUE 1 )", ); assert_eq!( ParserError::ParserError("Expected: AS, found: (".to_string()), res.unwrap_err() ); let res = pg().parse_sql_statements( "ALTER TABLE t ALTER COLUMN id ADD GENERATED AS IDENTITY ( INCREMENT )", ); assert_eq!( ParserError::ParserError("Expected: a value, found: )".to_string()), res.unwrap_err() ); let res = pg().parse_sql_statements("ALTER TABLE t ALTER COLUMN id ADD GENERATED AS IDENTITY ("); assert_eq!( ParserError::ParserError("Expected: ), found: EOF".to_string()), res.unwrap_err() ); } #[test] fn parse_alter_table_add_columns() { match pg().verified_stmt("ALTER TABLE IF EXISTS ONLY tab ADD COLUMN a TEXT, ADD COLUMN b INT") { Statement::AlterTable(AlterTable { name, if_exists, only, operations, .. }) => { assert_eq!(name.to_string(), "tab"); assert!(if_exists); assert!(only); assert_eq!( operations, vec![ AlterTableOperation::AddColumn { column_keyword: true, if_not_exists: false, column_def: ColumnDef { name: "a".into(), data_type: DataType::Text, options: vec![], }, column_position: None, }, AlterTableOperation::AddColumn { column_keyword: true, if_not_exists: false, column_def: ColumnDef { name: "b".into(), data_type: DataType::Int(None), options: vec![], }, column_position: None, }, ] ); } _ => unreachable!(), } } #[test] fn parse_alter_table_owner_to() { struct TestCase { sql: &'static str, expected_owner: Owner, } let test_cases = vec![ TestCase { sql: "ALTER TABLE tab OWNER TO new_owner", expected_owner: Owner::Ident(Ident::new("new_owner".to_string())), }, TestCase { sql: "ALTER TABLE tab OWNER TO postgres", expected_owner: Owner::Ident(Ident::new("postgres".to_string())), }, TestCase { sql: "ALTER TABLE tab OWNER TO CREATE", // treats CREATE as an identifier expected_owner: Owner::Ident(Ident::new("CREATE".to_string())), }, TestCase { sql: "ALTER TABLE tab OWNER TO \"new_owner\"", expected_owner: Owner::Ident(Ident::with_quote('\"', "new_owner".to_string())), }, TestCase { sql: "ALTER TABLE tab OWNER TO CURRENT_USER", expected_owner: Owner::CurrentUser, }, TestCase { sql: "ALTER TABLE tab OWNER TO CURRENT_ROLE", expected_owner: Owner::CurrentRole, }, TestCase { sql: "ALTER TABLE tab OWNER TO SESSION_USER", expected_owner: Owner::SessionUser, }, ]; for case in test_cases { match pg_and_generic().verified_stmt(case.sql) { Statement::AlterTable(AlterTable { name, if_exists: _, only: _, operations, .. }) => { assert_eq!(name.to_string(), "tab"); assert_eq!( operations, vec![AlterTableOperation::OwnerTo { new_owner: case.expected_owner.clone() }] ); } _ => unreachable!("Expected an AlterTable statement"), } } let res = pg().parse_sql_statements("ALTER TABLE tab OWNER TO CREATE FOO"); assert_eq!( ParserError::ParserError("Expected: end of statement, found: FOO".to_string()), res.unwrap_err() ); let res = pg().parse_sql_statements("ALTER TABLE tab OWNER TO 4"); assert_eq!( ParserError::ParserError("Expected: CURRENT_USER, CURRENT_ROLE, SESSION_USER or identifier after OWNER TO. sql parser error: Expected: identifier, found: 4".to_string()), res.unwrap_err() ); } #[test] fn parse_create_table_if_not_exists() { let sql = "CREATE TABLE IF NOT EXISTS uk_cities ()"; let ast = pg_and_generic().verified_stmt(sql); match ast { Statement::CreateTable(CreateTable { name, if_not_exists: true, .. }) => { assert_eq!("uk_cities", name.to_string()); } _ => unreachable!(), } } #[test] fn parse_bad_if_not_exists() { let res = pg().parse_sql_statements("CREATE TABLE NOT EXISTS uk_cities ()"); assert_eq!( ParserError::ParserError("Expected: end of statement, found: EXISTS".to_string()), res.unwrap_err() ); let res = pg().parse_sql_statements("CREATE TABLE IF EXISTS uk_cities ()"); assert_eq!( ParserError::ParserError("Expected: end of statement, found: EXISTS".to_string()), res.unwrap_err() ); let res = pg().parse_sql_statements("CREATE TABLE IF uk_cities ()"); assert_eq!( ParserError::ParserError("Expected: end of statement, found: uk_cities".to_string()), res.unwrap_err() ); let res = pg().parse_sql_statements("CREATE TABLE IF NOT uk_cities ()"); assert_eq!( ParserError::ParserError("Expected: end of statement, found: NOT".to_string()), res.unwrap_err() ); } #[test] fn parse_create_schema_if_not_exists() { let sql = "CREATE SCHEMA IF NOT EXISTS schema_name"; let ast = pg_and_generic().verified_stmt(sql); match ast { Statement::CreateSchema { if_not_exists: true, schema_name, .. } => assert_eq!("schema_name", schema_name.to_string()), _ => unreachable!(), } } #[test] fn parse_drop_schema_if_exists() { let sql = "DROP SCHEMA IF EXISTS schema_name"; let ast = pg().verified_stmt(sql); match ast { Statement::Drop { object_type, if_exists: true, .. } => assert_eq!(object_type, ObjectType::Schema), _ => unreachable!(), } } #[test] fn parse_copy_from_stdin() { let sql = r#"COPY public.actor (actor_id, first_name, last_name, last_update, value) FROM stdin; 1 PENELOPE GUINESS 2006-02-15 09:34:33 0.11111 2 NICK WAHLBERG 2006-02-15 09:34:33 0.22222 3 ED CHASE 2006-02-15 09:34:33 0.312323 4 JENNIFER DAVIS 2006-02-15 09:34:33 0.3232 5 JOHNNY LOLLOBRIGIDA 2006-02-15 09:34:33 1.343 6 BETTE NICHOLSON 2006-02-15 09:34:33 5.0 7 GRACE MOSTEL 2006-02-15 09:34:33 6.0 8 MATTHEW JOHANSSON 2006-02-15 09:34:33 7.0 9 JOE SWANK 2006-02-15 09:34:33 8.0 10 CHRISTIAN GABLE 2006-02-15 09:34:33 9.1 11 ZERO CAGE 2006-02-15 09:34:33 10.001 12 KARL BERRY 2017-11-02 19:15:42.308637+08 11.001 A Fateful Reflection of a Waitress And a Boat who must Discover a Sumo Wrestler in Ancient China Kwara & Kogi {"Deleted Scenes","Behind the Scenes"} 'awe':5 'awe-inspir':4 'barbarella':1 'cat':13 'conquer':16 'dog':18 'feminist':10 'inspir':6 'monasteri':21 'must':15 'stori':7 'streetcar':2 PHP ₱ USD $ \N Some other value \\."#; pg_and_generic().one_statement_parses_to(sql, ""); } #[test] fn parse_copy_from_stdin_without_semicolon() { let stmt = pg().verified_stmt("COPY bitwise_test FROM STDIN NULL 'null'"); assert_eq!( stmt, Statement::Copy { source: CopySource::Table { table_name: ObjectName::from(vec!["bitwise_test".into()]), columns: vec![], }, to: false, target: CopyTarget::Stdin, options: vec![], legacy_options: vec![CopyLegacyOption::Null("null".into())], values: vec![], } ); } #[test] fn parse_copy_from_stdin_without_semicolon_variants() { // This covers additional COPY ... FROM STDIN shapes without inline payload. // `parse_copy_from_stdin_without_semicolon` asserts the legacy NULL option details. let cases = [ "COPY varbit_table FROM STDIN", "COPY bit_table FROM STDIN", "COPY copytest2 (test) FROM STDIN", "COPY copytest3 FROM STDIN CSV HEADER", "COPY copytest4 FROM STDIN (HEADER)", "COPY parted_copytest FROM STDIN", "COPY tab_progress_reporting FROM STDIN", "COPY oversized_column_default FROM STDIN", "COPY x (a, b, c, d, e) FROM STDIN", "COPY header_copytest (c, a) FROM STDIN", "COPY atest5 (two) FROM STDIN", "COPY main_table (a, b) FROM STDIN", ]; for sql in cases { match pg().verified_stmt(sql) { Statement::Copy { to: false, target: CopyTarget::Stdin, values, .. } => { assert!( values.is_empty(), "expected no inline COPY payload for `{sql}`" ); } _ => panic!("expected COPY ... FROM STDIN statement for `{sql}`"), } } } #[test] fn test_copy_from() { let stmt = pg().verified_stmt("COPY users FROM 'data.csv'"); assert_eq!( stmt, Statement::Copy { source: CopySource::Table { table_name: ObjectName::from(vec!["users".into()]), columns: vec![], }, to: false, target: CopyTarget::File { filename: "data.csv".to_string(), }, options: vec![], legacy_options: vec![], values: vec![], } ); let stmt = pg().verified_stmt("COPY users FROM 'data.csv' DELIMITER ','"); assert_eq!( stmt, Statement::Copy { source: CopySource::Table { table_name: ObjectName::from(vec!["users".into()]), columns: vec![], }, to: false, target: CopyTarget::File { filename: "data.csv".to_string(), }, options: vec![], legacy_options: vec![CopyLegacyOption::Delimiter(',')], values: vec![], } ); let stmt = pg().verified_stmt("COPY users FROM 'data.csv' DELIMITER ',' CSV HEADER"); assert_eq!( stmt, Statement::Copy { source: CopySource::Table { table_name: ObjectName::from(vec!["users".into()]), columns: vec![], }, to: false, target: CopyTarget::File { filename: "data.csv".to_string(), }, options: vec![], legacy_options: vec![ CopyLegacyOption::Delimiter(','), CopyLegacyOption::Csv(vec![CopyLegacyCsvOption::Header,]) ], values: vec![], } ); } #[test] fn test_copy_to() { let stmt = pg().verified_stmt("COPY users TO 'data.csv'"); assert_eq!( stmt, Statement::Copy { source: CopySource::Table { table_name: ObjectName::from(vec!["users".into()]), columns: vec![], }, to: true, target: CopyTarget::File { filename: "data.csv".to_string(), }, options: vec![], legacy_options: vec![], values: vec![], } ); let stmt = pg().verified_stmt("COPY users TO 'data.csv' DELIMITER ','"); assert_eq!( stmt, Statement::Copy { source: CopySource::Table { table_name: ObjectName::from(vec!["users".into()]), columns: vec![], }, to: true, target: CopyTarget::File { filename: "data.csv".to_string(), }, options: vec![], legacy_options: vec![CopyLegacyOption::Delimiter(',')], values: vec![], } ); let stmt = pg().verified_stmt("COPY users TO 'data.csv' DELIMITER ',' CSV HEADER"); assert_eq!( stmt, Statement::Copy { source: CopySource::Table { table_name: ObjectName::from(vec!["users".into()]), columns: vec![], }, to: true, target: CopyTarget::File { filename: "data.csv".to_string(), }, options: vec![], legacy_options: vec![ CopyLegacyOption::Delimiter(','), CopyLegacyOption::Csv(vec![CopyLegacyCsvOption::Header,]) ], values: vec![], } ) } #[test] fn parse_copy_from() { let sql = "COPY table (a, b) FROM 'file.csv' WITH ( FORMAT CSV, FREEZE, FREEZE TRUE, FREEZE FALSE, DELIMITER ',', NULL '', HEADER, HEADER TRUE, HEADER FALSE, QUOTE '\"', ESCAPE '\\', FORCE_QUOTE (a, b), FORCE_NOT_NULL (a), FORCE_NULL (b), ENCODING 'utf8' )"; assert_eq!( pg_and_generic().one_statement_parses_to(sql, ""), Statement::Copy { source: CopySource::Table { table_name: ObjectName::from(vec!["table".into()]), columns: vec!["a".into(), "b".into()], }, to: false, target: CopyTarget::File { filename: "file.csv".into() }, options: vec![ CopyOption::Format("CSV".into()), CopyOption::Freeze(true), CopyOption::Freeze(true), CopyOption::Freeze(false), CopyOption::Delimiter(','), CopyOption::Null("".into()), CopyOption::Header(true), CopyOption::Header(true), CopyOption::Header(false), CopyOption::Quote('"'), CopyOption::Escape('\\'), CopyOption::ForceQuote(vec!["a".into(), "b".into()]), CopyOption::ForceNotNull(vec!["a".into()]), CopyOption::ForceNull(vec!["b".into()]), CopyOption::Encoding("utf8".into()), ], legacy_options: vec![], values: vec![], } ); } #[test] fn parse_copy_from_error() { let res = pg().parse_sql_statements("COPY (SELECT 42 AS a, 'hello' AS b) FROM 'query.csv'"); assert_eq!( ParserError::ParserError("COPY ... FROM does not support query as a source".to_string()), res.unwrap_err() ); } #[test] fn parse_copy_to() { let stmt = pg().verified_stmt("COPY users TO 'data.csv'"); assert_eq!( stmt, Statement::Copy { source: CopySource::Table { table_name: ObjectName::from(vec!["users".into()]), columns: vec![], }, to: true, target: CopyTarget::File { filename: "data.csv".to_string(), }, options: vec![], legacy_options: vec![], values: vec![], } ); let stmt = pg().verified_stmt("COPY country TO STDOUT (DELIMITER '|')"); assert_eq!( stmt, Statement::Copy { source: CopySource::Table { table_name: ObjectName::from(vec!["country".into()]), columns: vec![], }, to: true, target: CopyTarget::Stdout, options: vec![CopyOption::Delimiter('|')], legacy_options: vec![], values: vec![], } ); let stmt = pg().verified_stmt("COPY country TO PROGRAM 'gzip > /usr1/proj/bray/sql/country_data.gz'"); assert_eq!( stmt, Statement::Copy { source: CopySource::Table { table_name: ObjectName::from(vec!["country".into()]), columns: vec![], }, to: true, target: CopyTarget::Program { command: "gzip > /usr1/proj/bray/sql/country_data.gz".into(), }, options: vec![], legacy_options: vec![], values: vec![], } ); let stmt = pg().verified_stmt("COPY (SELECT 42 AS a, 'hello' AS b) TO 'query.csv'"); assert_eq!( stmt, Statement::Copy { source: CopySource::Query(Box::new(Query { with: None, body: Box::new(SetExpr::Select(Box::new(Select { select_token: AttachedToken::empty(), optimizer_hints: vec![], distinct: None, select_modifiers: None, top: None, top_before_distinct: false, projection: vec![ SelectItem::ExprWithAlias { expr: Expr::value(number("42")), alias: Ident { value: "a".into(), quote_style: None, span: Span::empty(), }, }, SelectItem::ExprWithAlias { expr: Expr::Value( (Value::SingleQuotedString("hello".into())).with_empty_span() ), alias: Ident { value: "b".into(), quote_style: None, span: Span::empty(), }, } ], exclude: None, into: None, from: vec![], lateral_views: vec![], prewhere: None, selection: None, group_by: GroupByExpr::Expressions(vec![], vec![]), having: None, named_window: vec![], window_before_qualify: false, cluster_by: vec![], distribute_by: vec![], sort_by: vec![], qualify: None, value_table_mode: None, connect_by: vec![], flavor: SelectFlavor::Standard, }))), order_by: None, limit_clause: None, fetch: None, locks: vec![], for_clause: None, settings: None, format_clause: None, pipe_operators: vec![], })), to: true, target: CopyTarget::File { filename: "query.csv".into(), }, options: vec![], legacy_options: vec![], values: vec![], } ) } #[test] fn parse_copy_from_before_v9_0() { let stmt = pg().verified_stmt("COPY users FROM 'data.csv' BINARY DELIMITER ',' NULL 'null' CSV HEADER QUOTE '\"' ESCAPE '\\' FORCE NOT NULL column"); assert_eq!( stmt, Statement::Copy { source: CopySource::Table { table_name: ObjectName::from(vec!["users".into()]), columns: vec![], }, to: false, target: CopyTarget::File { filename: "data.csv".to_string(), }, options: vec![], legacy_options: vec![ CopyLegacyOption::Binary, CopyLegacyOption::Delimiter(','), CopyLegacyOption::Null("null".into()), CopyLegacyOption::Csv(vec![ CopyLegacyCsvOption::Header, CopyLegacyCsvOption::Quote('\"'), CopyLegacyCsvOption::Escape('\\'), CopyLegacyCsvOption::ForceNotNull(vec!["column".into()]), ]), ], values: vec![], } ); // test 'AS' keyword let sql = "COPY users FROM 'data.csv' DELIMITER AS ',' NULL AS 'null' CSV QUOTE AS '\"' ESCAPE AS '\\'"; assert_eq!( pg_and_generic().one_statement_parses_to(sql, ""), Statement::Copy { source: CopySource::Table { table_name: ObjectName::from(vec!["users".into()]), columns: vec![], }, to: false, target: CopyTarget::File { filename: "data.csv".to_string(), }, options: vec![], legacy_options: vec![ CopyLegacyOption::Delimiter(','), CopyLegacyOption::Null("null".into()), CopyLegacyOption::Csv(vec![ CopyLegacyCsvOption::Quote('\"'), CopyLegacyCsvOption::Escape('\\'), ]), ], values: vec![], } ); } #[test] fn parse_copy_to_before_v9_0() { let stmt = pg().verified_stmt("COPY users TO 'data.csv' BINARY DELIMITER ',' NULL 'null' CSV HEADER QUOTE '\"' ESCAPE '\\' FORCE QUOTE column"); assert_eq!( stmt, Statement::Copy { source: CopySource::Table { table_name: ObjectName::from(vec!["users".into()]), columns: vec![], }, to: true, target: CopyTarget::File { filename: "data.csv".to_string(), }, options: vec![], legacy_options: vec![ CopyLegacyOption::Binary, CopyLegacyOption::Delimiter(','), CopyLegacyOption::Null("null".into()), CopyLegacyOption::Csv(vec![ CopyLegacyCsvOption::Header, CopyLegacyCsvOption::Quote('\"'), CopyLegacyCsvOption::Escape('\\'), CopyLegacyCsvOption::ForceQuote(vec!["column".into()]), ]), ], values: vec![], } ) } #[test] fn parse_set() { let stmt = pg_and_generic().verified_stmt("SET a = b"); assert_eq!( stmt, Statement::Set(Set::SingleAssignment { scope: None, hivevar: false, variable: ObjectName::from(vec![Ident::new("a")]), values: vec![Expr::Identifier(Ident { value: "b".into(), quote_style: None, span: Span::empty(), })], }) ); let stmt = pg_and_generic().verified_stmt("SET a = 'b'"); assert_eq!( stmt, Statement::Set(Set::SingleAssignment { scope: None, hivevar: false, variable: ObjectName::from(vec![Ident::new("a")]), values: vec![Expr::Value( (Value::SingleQuotedString("b".into())).with_empty_span() )], }) ); let stmt = pg_and_generic().verified_stmt("SET a = 0"); assert_eq!( stmt, Statement::Set(Set::SingleAssignment { scope: None, hivevar: false, variable: ObjectName::from(vec![Ident::new("a")]), values: vec![Expr::value(number("0"))], }) ); let stmt = pg_and_generic().verified_stmt("SET a = DEFAULT"); assert_eq!( stmt, Statement::Set(Set::SingleAssignment { scope: None, hivevar: false, variable: ObjectName::from(vec![Ident::new("a")]), values: vec![Expr::Identifier(Ident::new("DEFAULT"))], }) ); let stmt = pg_and_generic().verified_stmt("SET LOCAL a = b"); assert_eq!( stmt, Statement::Set(Set::SingleAssignment { scope: Some(ContextModifier::Local), hivevar: false, variable: ObjectName::from(vec![Ident::new("a")]), values: vec![Expr::Identifier("b".into())], }) ); let stmt = pg_and_generic().verified_stmt("SET a.b.c = b"); assert_eq!( stmt, Statement::Set(Set::SingleAssignment { scope: None, hivevar: false, variable: ObjectName::from(vec![Ident::new("a"), Ident::new("b"), Ident::new("c")]), values: vec![Expr::Identifier(Ident { value: "b".into(), quote_style: None, span: Span::empty(), })], }) ); let stmt = pg_and_generic().one_statement_parses_to( "SET hive.tez.auto.reducer.parallelism=false", "SET hive.tez.auto.reducer.parallelism = false", ); assert_eq!( stmt, Statement::Set(Set::SingleAssignment { scope: None, hivevar: false, variable: ObjectName::from(vec![ Ident::new("hive"), Ident::new("tez"), Ident::new("auto"), Ident::new("reducer"), Ident::new("parallelism") ]), values: vec![Expr::Value((Value::Boolean(false)).with_empty_span())], }) ); pg_and_generic().one_statement_parses_to("SET a TO b", "SET a = b"); assert_eq!( pg_and_generic().parse_sql_statements("SET"), Err(ParserError::ParserError( "Expected: identifier, found: EOF".to_string() )), ); assert_eq!( pg_and_generic().parse_sql_statements("SET a b"), Err(ParserError::ParserError( "Expected: equals sign or TO, found: b".to_string() )), ); assert_eq!( pg_and_generic().parse_sql_statements("SET a ="), Err(ParserError::ParserError( "Expected: variable value, found: EOF".to_string() )), ); } #[test] fn parse_set_role() { let query = "SET SESSION ROLE NONE"; let stmt = pg_and_generic().verified_stmt(query); assert_eq!( stmt, Statement::Set(Set::SetRole { context_modifier: Some(ContextModifier::Session), role_name: None, }) ); assert_eq!(query, stmt.to_string()); let query = "SET LOCAL ROLE \"rolename\""; let stmt = pg_and_generic().verified_stmt(query); assert_eq!( stmt, Statement::Set(Set::SetRole { context_modifier: Some(ContextModifier::Local), role_name: Some(Ident { value: "rolename".to_string(), quote_style: Some('\"'), span: Span::empty(), }), }) ); assert_eq!(query, stmt.to_string()); let query = "SET ROLE 'rolename'"; let stmt = pg_and_generic().verified_stmt(query); assert_eq!( stmt, Statement::Set(Set::SetRole { context_modifier: None, role_name: Some(Ident { value: "rolename".to_string(), quote_style: Some('\''), span: Span::empty(), }), }) ); assert_eq!(query, stmt.to_string()); } #[test] fn parse_show() { let stmt = pg_and_generic().verified_stmt("SHOW a a"); assert_eq!( stmt, Statement::ShowVariable { variable: vec!["a".into(), "a".into()] } ); let stmt = pg_and_generic().verified_stmt("SHOW ALL ALL"); assert_eq!( stmt, Statement::ShowVariable { variable: vec!["ALL".into(), "ALL".into()] } ) } #[test] fn parse_deallocate() { let stmt = pg_and_generic().verified_stmt("DEALLOCATE a"); assert_eq!( stmt, Statement::Deallocate { name: "a".into(), prepare: false, } ); let stmt = pg_and_generic().verified_stmt("DEALLOCATE ALL"); assert_eq!( stmt, Statement::Deallocate { name: "ALL".into(), prepare: false, } ); let stmt = pg_and_generic().verified_stmt("DEALLOCATE PREPARE a"); assert_eq!( stmt, Statement::Deallocate { name: "a".into(), prepare: true, } ); let stmt = pg_and_generic().verified_stmt("DEALLOCATE PREPARE ALL"); assert_eq!( stmt, Statement::Deallocate { name: "ALL".into(), prepare: true, } ); } #[test] fn parse_execute() { let stmt = pg_and_generic().verified_stmt("EXECUTE a"); assert_eq!( stmt, Statement::Execute { name: Some(ObjectName::from(vec!["a".into()])), parameters: vec![], has_parentheses: false, using: vec![], immediate: false, into: vec![], output: false, default: false, } ); let stmt = pg_and_generic().verified_stmt("EXECUTE a(1, 't')"); assert_eq!( stmt, Statement::Execute { name: Some(ObjectName::from(vec!["a".into()])), parameters: vec![ Expr::value(number("1")), Expr::Value((Value::SingleQuotedString("t".to_string())).with_empty_span()) ], has_parentheses: true, using: vec![], immediate: false, into: vec![], output: false, default: false, } ); let stmt = pg_and_generic() .verified_stmt("EXECUTE a USING CAST(1337 AS SMALLINT), CAST(7331 AS SMALLINT)"); assert_eq!( stmt, Statement::Execute { name: Some(ObjectName::from(vec!["a".into()])), parameters: vec![], has_parentheses: false, using: vec![ ExprWithAlias { expr: Expr::Cast { kind: CastKind::Cast, expr: Box::new(Expr::Value( (Value::Number("1337".parse().unwrap(), false)).with_empty_span() )), data_type: DataType::SmallInt(None), array: false, format: None }, alias: None }, ExprWithAlias { expr: Expr::Cast { kind: CastKind::Cast, expr: Box::new(Expr::Value( (Value::Number("7331".parse().unwrap(), false)).with_empty_span() )), data_type: DataType::SmallInt(None), array: false, format: None }, alias: None }, ], immediate: false, into: vec![], output: false, default: false, } ); } #[test] fn parse_prepare() { let stmt = pg_and_generic().verified_stmt("PREPARE a AS INSERT INTO customers VALUES (a1, a2, a3)"); let sub_stmt = match stmt { Statement::Prepare { name, data_types, statement, .. } => { assert_eq!(name, "a".into()); assert!(data_types.is_empty()); statement } _ => unreachable!(), }; match sub_stmt.as_ref() { Statement::Insert(Insert { table: table_name, columns, source: Some(source), .. }) => { assert_eq!(table_name.to_string(), "customers"); assert!(columns.is_empty()); let expected_values = [Parens::with_empty_span(vec![ Expr::Identifier("a1".into()), Expr::Identifier("a2".into()), Expr::Identifier("a3".into()), ])]; match &*source.body { SetExpr::Values(Values { rows, .. }) => { assert_eq!(rows.as_slice(), &expected_values) } _ => unreachable!(), } } _ => unreachable!(), }; let stmt = pg_and_generic() .verified_stmt("PREPARE a (INT, TEXT) AS SELECT * FROM customers WHERE customers.id = a1"); let sub_stmt = match stmt { Statement::Prepare { name, data_types, statement, .. } => { assert_eq!(name, "a".into()); assert_eq!(data_types, vec![DataType::Int(None), DataType::Text]); statement } _ => unreachable!(), }; assert_eq!( sub_stmt, Box::new(Statement::Query(Box::new(pg_and_generic().verified_query( "SELECT * FROM customers WHERE customers.id = a1" )))) ); } #[test] fn parse_pg_on_conflict() { let stmt = pg_and_generic().verified_stmt( "INSERT INTO distributors (did, dname) \ VALUES (5, 'Gizmo Transglobal'), (6, 'Associated Computing, Inc') \ ON CONFLICT(did) \ DO UPDATE SET dname = EXCLUDED.dname", ); match stmt { Statement::Insert(Insert { on: Some(OnInsert::OnConflict(OnConflict { conflict_target: Some(ConflictTarget::Columns(cols)), action, })), .. }) => { assert_eq!(vec![Ident::from("did")], cols); assert_eq!( OnConflictAction::DoUpdate(DoUpdate { assignments: vec![Assignment { target: AssignmentTarget::ColumnName(ObjectName::from( vec!["dname".into()] )), value: Expr::CompoundIdentifier(vec!["EXCLUDED".into(), "dname".into()]) },], selection: None }), action ); } _ => unreachable!(), }; let stmt = pg_and_generic().verified_stmt( "INSERT INTO distributors (did, dname, area) \ VALUES (5, 'Gizmo Transglobal', 'Mars'), (6, 'Associated Computing, Inc', 'Venus') \ ON CONFLICT(did, area) \ DO UPDATE SET dname = EXCLUDED.dname, area = EXCLUDED.area", ); match stmt { Statement::Insert(Insert { on: Some(OnInsert::OnConflict(OnConflict { conflict_target: Some(ConflictTarget::Columns(cols)), action, })), .. }) => { assert_eq!(vec![Ident::from("did"), Ident::from("area"),], cols); assert_eq!( OnConflictAction::DoUpdate(DoUpdate { assignments: vec![ Assignment { target: AssignmentTarget::ColumnName(ObjectName::from(vec![ "dname".into() ])), value: Expr::CompoundIdentifier(vec![ "EXCLUDED".into(), "dname".into() ]) }, Assignment { target: AssignmentTarget::ColumnName(ObjectName::from(vec![ "area".into() ])), value: Expr::CompoundIdentifier(vec!["EXCLUDED".into(), "area".into()]) }, ], selection: None }), action ); } _ => unreachable!(), }; let stmt = pg_and_generic().verified_stmt( "INSERT INTO distributors (did, dname) \ VALUES (5, 'Gizmo Transglobal'), (6, 'Associated Computing, Inc') \ ON CONFLICT DO NOTHING", ); match stmt { Statement::Insert(Insert { on: Some(OnInsert::OnConflict(OnConflict { conflict_target: None, action, })), .. }) => { assert_eq!(OnConflictAction::DoNothing, action); } _ => unreachable!(), }; let stmt = pg_and_generic().verified_stmt( "INSERT INTO distributors (did, dname, dsize) \ VALUES (5, 'Gizmo Transglobal', 1000), (6, 'Associated Computing, Inc', 1010) \ ON CONFLICT(did) \ DO UPDATE SET dname = $1 WHERE dsize > $2", ); match stmt { Statement::Insert(Insert { on: Some(OnInsert::OnConflict(OnConflict { conflict_target: Some(ConflictTarget::Columns(cols)), action, })), .. }) => { assert_eq!(vec![Ident::from("did")], cols); assert_eq!( OnConflictAction::DoUpdate(DoUpdate { assignments: vec![Assignment { target: AssignmentTarget::ColumnName(ObjectName::from( vec!["dname".into()] )), value: Expr::Value( (Value::Placeholder("$1".to_string())).with_empty_span() ) },], selection: Some(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident { value: "dsize".to_string(), quote_style: None, span: Span::empty(), })), op: BinaryOperator::Gt, right: Box::new(Expr::Value( (Value::Placeholder("$2".to_string())).with_empty_span() )) }) }), action ); } _ => unreachable!(), }; let stmt = pg_and_generic().verified_stmt( "INSERT INTO distributors (did, dname, dsize) \ VALUES (5, 'Gizmo Transglobal', 1000), (6, 'Associated Computing, Inc', 1010) \ ON CONFLICT ON CONSTRAINT distributors_did_pkey \ DO UPDATE SET dname = $1 WHERE dsize > $2", ); match stmt { Statement::Insert(Insert { on: Some(OnInsert::OnConflict(OnConflict { conflict_target: Some(ConflictTarget::OnConstraint(cname)), action, })), .. }) => { assert_eq!( ObjectName::from(vec![Ident::from("distributors_did_pkey")]), cname ); assert_eq!( OnConflictAction::DoUpdate(DoUpdate { assignments: vec![Assignment { target: AssignmentTarget::ColumnName(ObjectName::from( vec!["dname".into()] )), value: Expr::Value( (Value::Placeholder("$1".to_string())).with_empty_span() ) },], selection: Some(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident { value: "dsize".to_string(), quote_style: None, span: Span::empty(), })), op: BinaryOperator::Gt, right: Box::new(Expr::Value( (Value::Placeholder("$2".to_string())).with_empty_span() )) }) }), action ); } _ => unreachable!(), }; } #[test] fn parse_pg_returning() { let stmt = pg_and_generic().verified_stmt( "INSERT INTO distributors (did, dname) VALUES (DEFAULT, 'XYZ Widgets') RETURNING did", ); match stmt { Statement::Insert(Insert { returning, .. }) => { assert_eq!( Some(vec![SelectItem::UnnamedExpr(Expr::Identifier( "did".into() )),]), returning ); } _ => unreachable!(), }; let stmt = pg_and_generic().verified_stmt( "UPDATE weather SET temp_lo = temp_lo + 1, temp_hi = temp_lo + 15, prcp = DEFAULT \ WHERE city = 'San Francisco' AND date = '2003-07-03' \ RETURNING temp_lo AS lo, temp_hi AS hi, prcp", ); match stmt { Statement::Update(Update { returning, .. }) => { assert_eq!( Some(vec![ SelectItem::ExprWithAlias { expr: Expr::Identifier("temp_lo".into()), alias: "lo".into() }, SelectItem::ExprWithAlias { expr: Expr::Identifier("temp_hi".into()), alias: "hi".into() }, SelectItem::UnnamedExpr(Expr::Identifier("prcp".into())), ]), returning ); } _ => unreachable!(), }; let stmt = pg_and_generic().verified_stmt("DELETE FROM tasks WHERE status = 'DONE' RETURNING *"); match stmt { Statement::Delete(Delete { returning, .. }) => { assert_eq!( Some(vec![SelectItem::Wildcard( WildcardAdditionalOptions::default() ),]), returning ); } _ => unreachable!(), }; } fn test_operator(operator: &str, dialect: &TestedDialects, expected: BinaryOperator) { let operator_tokens = sqlparser::tokenizer::Tokenizer::new(&PostgreSqlDialect {}, &format!("a{operator}b")) .tokenize() .unwrap(); assert_eq!( operator_tokens.len(), 3, "binary op should be 3 tokens, not {operator_tokens:?}" ); let expected_expr = Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("a"))), op: expected, right: Box::new(Expr::Identifier(Ident::new("b"))), }; let str_expr_canonical = format!("a {operator} b"); assert_eq!(expected_expr, dialect.verified_expr(&str_expr_canonical)); assert_eq!( expected_expr, dialect.expr_parses_to(&format!("a{operator}b"), &str_expr_canonical) ); } #[test] fn parse_pg_binary_ops() { let binary_ops = &[ // Sharp char and Caret cannot be used with Generic Dialect, it conflicts with identifiers ("#", BinaryOperator::PGBitwiseXor, pg()), ("^", BinaryOperator::PGExp, pg()), (">>", BinaryOperator::PGBitwiseShiftRight, pg_and_generic()), ("<<", BinaryOperator::PGBitwiseShiftLeft, pg_and_generic()), ("&&", BinaryOperator::PGOverlap, pg()), ("^@", BinaryOperator::PGStartsWith, pg()), ]; for (str_op, op, dialects) in binary_ops { test_operator(str_op, dialects, op.clone()); } } #[test] fn parse_pg_custom_binary_ops() { // Postgres supports declaring custom binary operators, using any character in the following set: // + - * / < > = ~ ! @ # % ^ & | ` ? // Here, we test the ones used by common extensions let operators = [ // PostGIS "&&&", // n-D bounding boxes intersect "|=|", // distance between A and B trajectories at their closest point of approach "<<#>>", // n-D distance between A and B bounding boxes // PGroonga "&@", // Full text search by a keyword "&@~", // Full text search by easy to use query language "&@*", // Similar search "&`", // Advanced search by ECMAScript like query language "&@|", // Full text search by an array of keywords "&@~|", // Full text search by an array of queries in easy to use query language // pgtrgm "<<%", // second argument has a continuous extent of an ordered trigram set that matches word boundaries "%>>", // commutator of <<% "<<<->", // distance between arguments // hstore "#=", // Replace fields with matching values from hstore // ranges "-|-", // Is adjacent to // pg_similarity "~++", // L1 distance "~##", // Cosine Distance "~-~", // Dice Coefficient "~!!", // Euclidean Distance "~@~", // Hamming Distance "~??", // Jaccard Coefficient "~%%", // Jaro Distance "~@@", // Jaro-Winkler Distance "~==", // Levenshtein Distance "~^^", // Matching Coefficient "~||", // Monge-Elkan Coefficient "~#~", // Needleman-Wunsch Coefficient "~**", // Overlap Coefficient "~~~", // Q-Gram Distance "~=~", // Smith-Waterman Coefficient "~!~", // Smith-Waterman-Gotoh Coefficient "~*~", // Soundex Distance // soundex_operator ">@@<", // Soundex matches "<@@>", // Soundex doesn't match ]; for op in &operators { test_operator(op, &pg(), BinaryOperator::Custom(op.to_string())); } } #[test] fn parse_ampersand_arobase() { // In SQL Server, a&@b means (a) & (@b), in PostgreSQL it means (a) &@ (b) pg().expr_parses_to("a&@b", "a &@ b"); } #[test] fn parse_pg_unary_ops() { let pg_unary_ops = &[ ("|/", UnaryOperator::PGSquareRoot), ("||/", UnaryOperator::PGCubeRoot), ("!!", UnaryOperator::PGPrefixFactorial), ("@", UnaryOperator::PGAbs), ]; for (str_op, op) in pg_unary_ops { let select = pg().verified_only_select(&format!("SELECT {}a", &str_op)); assert_eq!( SelectItem::UnnamedExpr(Expr::UnaryOp { op: *op, expr: Box::new(Expr::Identifier(Ident::new("a"))), }), select.projection[0] ); } } #[test] fn parse_pg_postfix_factorial() { let postfix_factorial = &[("!", UnaryOperator::PGPostfixFactorial)]; for (str_op, op) in postfix_factorial { let select = pg().verified_only_select(&format!("SELECT a{}", &str_op)); assert_eq!( SelectItem::UnnamedExpr(Expr::UnaryOp { op: *op, expr: Box::new(Expr::Identifier(Ident::new("a"))), }), select.projection[0] ); } } #[test] fn parse_pg_regex_match_ops() { let pg_regex_match_ops = &[ ("~", BinaryOperator::PGRegexMatch), ("~*", BinaryOperator::PGRegexIMatch), ("!~", BinaryOperator::PGRegexNotMatch), ("!~*", BinaryOperator::PGRegexNotIMatch), ]; // Match against a single value for (str_op, op) in pg_regex_match_ops { let select = pg().verified_only_select(&format!("SELECT 'abc' {str_op} '^a'")); assert_eq!( SelectItem::UnnamedExpr(Expr::BinaryOp { left: Box::new(Expr::Value(single_quoted_string("abc").with_empty_span(),)), op: op.clone(), right: Box::new(Expr::Value(single_quoted_string("^a").with_empty_span(),)), }), select.projection[0] ); } // Match against any value from an array for (str_op, op) in pg_regex_match_ops { let select = pg().verified_only_select(&format!("SELECT 'abc' {str_op} ANY(ARRAY['^a', 'x'])")); assert_eq!( SelectItem::UnnamedExpr(Expr::AnyOp { left: Box::new(Expr::Value(single_quoted_string("abc").with_empty_span(),)), compare_op: op.clone(), right: Box::new(Expr::Array(Array { elem: vec![ Expr::Value(single_quoted_string("^a").with_empty_span()), Expr::Value(single_quoted_string("x").with_empty_span()), ], named: true, })), is_some: false, }), select.projection[0] ) } } #[test] fn parse_pg_like_match_ops() { let pg_like_match_ops = &[ ("~~", BinaryOperator::PGLikeMatch), ("~~*", BinaryOperator::PGILikeMatch), ("!~~", BinaryOperator::PGNotLikeMatch), ("!~~*", BinaryOperator::PGNotILikeMatch), ]; // Match against a single value for (str_op, op) in pg_like_match_ops { let select = pg().verified_only_select(&format!("SELECT 'abc' {str_op} 'a_c%'")); assert_eq!( SelectItem::UnnamedExpr(Expr::BinaryOp { left: Box::new(Expr::Value(single_quoted_string("abc").with_empty_span(),)), op: op.clone(), right: Box::new(Expr::Value(single_quoted_string("a_c%").with_empty_span(),)), }), select.projection[0] ); } // Match against all values from an array for (str_op, op) in pg_like_match_ops { let select = pg().verified_only_select(&format!("SELECT 'abc' {str_op} ALL(ARRAY['a_c%'])")); assert_eq!( SelectItem::UnnamedExpr(Expr::AllOp { left: Box::new(Expr::Value(single_quoted_string("abc").with_empty_span(),)), compare_op: op.clone(), right: Box::new(Expr::Array(Array { elem: vec![Expr::Value(single_quoted_string("a_c%").with_empty_span())], named: true, })), }), select.projection[0] ) } } #[test] fn parse_array_index_expr() { let num: Vec = (0..=10) .map(|s| Expr::Value(number(&s.to_string()).with_empty_span())) .collect(); let sql = "SELECT foo[0] FROM foos"; let select = pg_and_generic().verified_only_select(sql); assert_eq!( &Expr::CompoundFieldAccess { root: Box::new(Expr::Identifier(Ident::new("foo"))), access_chain: vec![AccessExpr::Subscript(Subscript::Index { index: num[0].clone() })], }, expr_from_projection(only(&select.projection)), ); let sql = "SELECT foo[0][0] FROM foos"; let select = pg_and_generic().verified_only_select(sql); assert_eq!( &Expr::CompoundFieldAccess { root: Box::new(Expr::Identifier(Ident::new("foo"))), access_chain: vec![ AccessExpr::Subscript(Subscript::Index { index: num[0].clone() }), AccessExpr::Subscript(Subscript::Index { index: num[0].clone() }) ], }, expr_from_projection(only(&select.projection)), ); let sql = r#"SELECT bar[0]["baz"]["fooz"] FROM foos"#; let select = pg_and_generic().verified_only_select(sql); assert_eq!( &Expr::CompoundFieldAccess { root: Box::new(Expr::Identifier(Ident::new("bar"))), access_chain: vec![ AccessExpr::Subscript(Subscript::Index { index: num[0].clone() }), AccessExpr::Subscript(Subscript::Index { index: Expr::Identifier(Ident { value: "baz".to_string(), quote_style: Some('"'), span: Span::empty(), }) }), AccessExpr::Subscript(Subscript::Index { index: Expr::Identifier(Ident { value: "fooz".to_string(), quote_style: Some('"'), span: Span::empty(), }) }), ], }, expr_from_projection(only(&select.projection)), ); let sql = "SELECT (CAST(ARRAY[ARRAY[2, 3]] AS INT[][]))[1][2]"; let select = pg_and_generic().verified_only_select(sql); assert_eq!( &Expr::CompoundFieldAccess { root: Box::new(Expr::Nested(Box::new(Expr::Cast { kind: CastKind::Cast, expr: Box::new(Expr::Array(Array { elem: vec![Expr::Array(Array { elem: vec![num[2].clone(), num[3].clone(),], named: true, })], named: true, })), data_type: DataType::Array(ArrayElemTypeDef::SquareBracket( Box::new(DataType::Array(ArrayElemTypeDef::SquareBracket( Box::new(DataType::Int(None)), None ))), None )), array: false, format: None, }))), access_chain: vec![ AccessExpr::Subscript(Subscript::Index { index: num[1].clone() }), AccessExpr::Subscript(Subscript::Index { index: num[2].clone() }), ], }, expr_from_projection(only(&select.projection)), ); let sql = "SELECT ARRAY[]"; let select = pg_and_generic().verified_only_select(sql); assert_eq!( &Expr::Array(sqlparser::ast::Array { elem: vec![], named: true }), expr_from_projection(only(&select.projection)), ); } #[test] fn parse_array_subscript() { let tests = [ ( "(ARRAY[1, 2, 3, 4, 5, 6])[2]", Subscript::Index { index: Expr::value(number("2")), }, ), ( "(ARRAY[1, 2, 3, 4, 5, 6])[foo]", Subscript::Index { index: Expr::Identifier(Ident::new("foo")), }, ), ( "(ARRAY[1, 2, 3, 4, 5, 6])[2:5]", Subscript::Slice { lower_bound: Some(Expr::value(number("2"))), upper_bound: Some(Expr::value(number("5"))), stride: None, }, ), ( "(ARRAY[1, 2, 3, 4, 5, 6])[2:5:3]", Subscript::Slice { lower_bound: Some(Expr::value(number("2"))), upper_bound: Some(Expr::value(number("5"))), stride: Some(Expr::value(number("3"))), }, ), ( "arr[array_length(arr) - 3:array_length(arr) - 1]", Subscript::Slice { lower_bound: Some(Expr::BinaryOp { left: Box::new(call("array_length", [Expr::Identifier(Ident::new("arr"))])), op: BinaryOperator::Minus, right: Box::new(Expr::value(number("3"))), }), upper_bound: Some(Expr::BinaryOp { left: Box::new(call("array_length", [Expr::Identifier(Ident::new("arr"))])), op: BinaryOperator::Minus, right: Box::new(Expr::value(number("1"))), }), stride: None, }, ), ( "(ARRAY[1, 2, 3, 4, 5, 6])[:5]", Subscript::Slice { lower_bound: None, upper_bound: Some(Expr::value(number("5"))), stride: None, }, ), ( "(ARRAY[1, 2, 3, 4, 5, 6])[2:]", Subscript::Slice { lower_bound: Some(Expr::value(number("2"))), upper_bound: None, stride: None, }, ), ( "(ARRAY[1, 2, 3, 4, 5, 6])[:]", Subscript::Slice { lower_bound: None, upper_bound: None, stride: None, }, ), ]; for (sql, expect) in tests { let Expr::CompoundFieldAccess { access_chain, .. } = pg_and_generic().verified_expr(sql) else { panic!("expected subscript expr"); }; let Some(AccessExpr::Subscript(subscript)) = access_chain.last() else { panic!("expected subscript"); }; assert_eq!(expect, *subscript); } pg_and_generic().verified_expr("schedule[:2][2:]"); } #[test] fn parse_array_multi_subscript() { let expr = pg_and_generic().verified_expr("make_array(1, 2, 3)[1:2][2]"); assert_eq!( Expr::CompoundFieldAccess { root: Box::new(call( "make_array", vec![ Expr::value(number("1")), Expr::value(number("2")), Expr::value(number("3")) ] )), access_chain: vec![ AccessExpr::Subscript(Subscript::Slice { lower_bound: Some(Expr::value(number("1"))), upper_bound: Some(Expr::value(number("2"))), stride: None, }), AccessExpr::Subscript(Subscript::Index { index: Expr::value(number("2")), }), ], }, expr, ); } #[test] fn parse_create_index() { let sql = "CREATE INDEX IF NOT EXISTS my_index ON my_table(col1, col2)"; match pg().verified_stmt(sql) { Statement::CreateIndex(CreateIndex { name: Some(ObjectName(name)), table_name: ObjectName(table_name), using, columns, unique, concurrently, if_not_exists, nulls_distinct: None, include, with, predicate: None, index_options, alter_options, }) => { assert_eq_vec(&["my_index"], &name); assert_eq_vec(&["my_table"], &table_name); assert_eq!(None, using); assert!(!unique); assert!(!concurrently); assert!(if_not_exists); assert_eq_vec(&["col1", "col2"], &columns); assert!(include.is_empty()); assert!(with.is_empty()); assert!(index_options.is_empty()); assert!(alter_options.is_empty()); } _ => unreachable!(), } } #[test] fn parse_create_anonymous_index() { let sql = "CREATE INDEX ON my_table(col1, col2)"; match pg().verified_stmt(sql) { Statement::CreateIndex(CreateIndex { name, table_name: ObjectName(table_name), using, columns, unique, concurrently, if_not_exists, include, nulls_distinct: None, with, predicate: None, index_options, alter_options, }) => { assert_eq!(None, name); assert_eq_vec(&["my_table"], &table_name); assert_eq!(None, using); assert!(!unique); assert!(!concurrently); assert!(!if_not_exists); assert_eq_vec(&["col1", "col2"], &columns); assert!(include.is_empty()); assert!(with.is_empty()); assert!(index_options.is_empty()); assert!(alter_options.is_empty()); } _ => unreachable!(), } } #[test] /// Test to verify the correctness of parsing the `CREATE INDEX` statement with optional operator classes. /// /// # Implementative details /// /// At this time, since the parser library is not intended to take care of the semantics of the SQL statements, /// there is no way to verify the correctness of the operator classes, nor whether they are valid for the given /// index type. This test is only intended to verify that the parser can correctly parse the statement. For this /// reason, the test includes a `totally_not_valid` operator class. fn parse_create_indices_with_operator_classes() { let indices = [ IndexType::GIN, IndexType::GiST, IndexType::SPGiST, IndexType::Custom("CustomIndexType".into()), ]; let operator_classes: [Option; 4] = [ None, Some(ObjectName(vec![ObjectNamePart::Identifier(Ident::new( "gin_trgm_ops", ))])), Some(ObjectName(vec![ObjectNamePart::Identifier(Ident::new( "gist_trgm_ops", ))])), Some(ObjectName(vec![ObjectNamePart::Identifier(Ident::new( "totally_not_valid", ))])), ]; for expected_index_type in indices { for expected_operator_class in &operator_classes { let single_column_sql_statement = format!( "CREATE INDEX the_index_name ON users USING {expected_index_type} (concat_users_name(first_name, last_name){})", expected_operator_class.as_ref().map(|oc| format!(" {oc}")) .unwrap_or_default() ); let multi_column_sql_statement = format!( "CREATE INDEX the_index_name ON users USING {expected_index_type} (column_name, concat_users_name(first_name, last_name){})", expected_operator_class.as_ref().map(|oc| format!(" {oc}")) .unwrap_or_default() ); let expected_function_column = IndexColumn { column: OrderByExpr { expr: Expr::Function(Function { name: ObjectName(vec![ObjectNamePart::Identifier(Ident { value: "concat_users_name".to_owned(), quote_style: None, span: Span::empty(), })]), uses_odbc_syntax: false, parameters: FunctionArguments::None, args: FunctionArguments::List(FunctionArgumentList { duplicate_treatment: None, args: vec![ FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::Identifier( Ident { value: "first_name".to_owned(), quote_style: None, span: Span::empty(), }, ))), FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::Identifier( Ident { value: "last_name".to_owned(), quote_style: None, span: Span::empty(), }, ))), ], clauses: vec![], }), filter: None, null_treatment: None, over: None, within_group: vec![], }), options: OrderByOptions { asc: None, nulls_first: None, }, with_fill: None, }, operator_class: expected_operator_class.clone(), }; match pg().verified_stmt(&single_column_sql_statement) { Statement::CreateIndex(CreateIndex { name: Some(ObjectName(name)), table_name: ObjectName(table_name), using: Some(using), columns, unique: false, concurrently: false, if_not_exists: false, include, nulls_distinct: None, with, predicate: None, index_options, alter_options, }) => { assert_eq_vec(&["the_index_name"], &name); assert_eq_vec(&["users"], &table_name); assert_eq!(expected_index_type, using); assert_eq!(expected_function_column, columns[0],); assert!(include.is_empty()); assert!(with.is_empty()); assert!(index_options.is_empty()); assert!(alter_options.is_empty()); } _ => unreachable!(), } match pg().verified_stmt(&multi_column_sql_statement) { Statement::CreateIndex(CreateIndex { name: Some(ObjectName(name)), table_name: ObjectName(table_name), using: Some(using), columns, unique: false, concurrently: false, if_not_exists: false, include, nulls_distinct: None, with, predicate: None, index_options, alter_options, }) => { assert_eq_vec(&["the_index_name"], &name); assert_eq_vec(&["users"], &table_name); assert_eq!(expected_index_type, using); assert_eq!( IndexColumn { column: OrderByExpr { expr: Expr::Identifier(Ident { value: "column_name".to_owned(), quote_style: None, span: Span::empty() }), options: OrderByOptions { asc: None, nulls_first: None, }, with_fill: None, }, operator_class: None }, columns[0], ); assert_eq!(expected_function_column, columns[1],); assert!(include.is_empty()); assert!(with.is_empty()); assert!(index_options.is_empty()); assert!(alter_options.is_empty()); } _ => unreachable!(), } } } } #[test] fn parse_create_index_with_schema_qualified_operator_class() { let sql = "CREATE INDEX my_index ON my_table USING HNSW (embedding public.vector_cosine_ops)"; match pg().verified_stmt(sql) { Statement::CreateIndex(CreateIndex { columns, .. }) => { assert_eq!(1, columns.len()); let idx_col = &columns[0]; // Verify the column name match &idx_col.column.expr { Expr::Identifier(ident) => { assert_eq!("embedding", ident.value); } _ => panic!("Expected identifier expression"), } // Verify the schema-qualified operator class assert_eq!( Some(ObjectName(vec![ ObjectNamePart::Identifier(Ident::new("public")), ObjectNamePart::Identifier(Ident::new("vector_cosine_ops")), ])), idx_col.operator_class ); } _ => unreachable!(), } } #[test] fn parse_create_bloom() { let sql = "CREATE INDEX bloomidx ON tbloom USING BLOOM (i1, i2, i3) WITH (length = 80, col1 = 2, col2 = 2, col3 = 4)"; match pg().verified_stmt(sql) { Statement::CreateIndex(CreateIndex { name: Some(ObjectName(name)), table_name: ObjectName(table_name), using: Some(using), columns, unique: false, concurrently: false, if_not_exists: false, include, nulls_distinct: None, with, predicate: None, index_options, alter_options, }) => { assert_eq_vec(&["bloomidx"], &name); assert_eq_vec(&["tbloom"], &table_name); assert_eq!(IndexType::Bloom, using); assert_eq_vec(&["i1", "i2", "i3"], &columns); assert!(include.is_empty()); assert_eq!( vec![ Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("length"))), op: BinaryOperator::Eq, right: Box::new(Expr::Value(number("80").into())), }, Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("col1"))), op: BinaryOperator::Eq, right: Box::new(Expr::Value(number("2").into())), }, Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("col2"))), op: BinaryOperator::Eq, right: Box::new(Expr::Value(number("2").into())), }, Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("col3"))), op: BinaryOperator::Eq, right: Box::new(Expr::Value(number("4").into())), }, ], with ); assert!(index_options.is_empty()); assert!(alter_options.is_empty()); } _ => unreachable!(), } } #[test] fn parse_create_brin() { let sql = "CREATE INDEX brin_sensor_data_recorded_at ON sensor_data USING BRIN (recorded_at)"; match pg().verified_stmt(sql) { Statement::CreateIndex(CreateIndex { name: Some(ObjectName(name)), table_name: ObjectName(table_name), using: Some(using), columns, unique: false, concurrently: false, if_not_exists: false, include, nulls_distinct: None, with, predicate: None, index_options, alter_options, }) => { assert_eq_vec(&["brin_sensor_data_recorded_at"], &name); assert_eq_vec(&["sensor_data"], &table_name); assert_eq!(IndexType::BRIN, using); assert_eq_vec(&["recorded_at"], &columns); assert!(include.is_empty()); assert!(with.is_empty()); assert!(index_options.is_empty()); assert!(alter_options.is_empty()); } _ => unreachable!(), } } #[test] fn parse_create_table_with_inherits() { let single_inheritance_sql = "CREATE TABLE child_table (child_column INT) INHERITS (public.parent_table)"; match pg().verified_stmt(single_inheritance_sql) { Statement::CreateTable(CreateTable { inherits: Some(inherits), .. }) => { assert_eq_vec(&["public", "parent_table"], &inherits[0].0); } _ => unreachable!(), } let double_inheritance_sql = "CREATE TABLE child_table (child_column INT) INHERITS (public.parent_table, pg_catalog.pg_settings)"; match pg().verified_stmt(double_inheritance_sql) { Statement::CreateTable(CreateTable { inherits: Some(inherits), .. }) => { assert_eq_vec(&["public", "parent_table"], &inherits[0].0); assert_eq_vec(&["pg_catalog", "pg_settings"], &inherits[1].0); } _ => unreachable!(), } } #[test] fn parse_create_table_with_empty_inherits_fails() { assert!(matches!( pg().parse_sql_statements("CREATE TABLE child_table (child_column INT) INHERITS ()"), Err(ParserError::ParserError(_)) )); } #[test] fn parse_create_index_concurrently() { let sql = "CREATE INDEX CONCURRENTLY IF NOT EXISTS my_index ON my_table(col1, col2)"; match pg().verified_stmt(sql) { Statement::CreateIndex(CreateIndex { name: Some(ObjectName(name)), table_name: ObjectName(table_name), using, columns, unique, concurrently, if_not_exists, include, nulls_distinct: None, with, predicate: None, index_options, alter_options, }) => { assert_eq_vec(&["my_index"], &name); assert_eq_vec(&["my_table"], &table_name); assert_eq!(None, using); assert!(!unique); assert!(concurrently); assert!(if_not_exists); assert_eq_vec(&["col1", "col2"], &columns); assert!(include.is_empty()); assert!(with.is_empty()); assert!(index_options.is_empty()); assert!(alter_options.is_empty()); } _ => unreachable!(), } } #[test] fn parse_create_index_with_predicate() { let sql = "CREATE INDEX IF NOT EXISTS my_index ON my_table(col1, col2) WHERE col3 IS NULL"; match pg().verified_stmt(sql) { Statement::CreateIndex(CreateIndex { name: Some(ObjectName(name)), table_name: ObjectName(table_name), using, columns, unique, concurrently, if_not_exists, include, nulls_distinct: None, with, predicate: Some(_), index_options, alter_options, }) => { assert_eq_vec(&["my_index"], &name); assert_eq_vec(&["my_table"], &table_name); assert_eq!(None, using); assert!(!unique); assert!(!concurrently); assert!(if_not_exists); assert_eq_vec(&["col1", "col2"], &columns); assert!(include.is_empty()); assert!(with.is_empty()); assert!(index_options.is_empty()); assert!(alter_options.is_empty()); } _ => unreachable!(), } } #[test] fn parse_create_index_with_include() { let sql = "CREATE INDEX IF NOT EXISTS my_index ON my_table(col1, col2) INCLUDE (col3, col4)"; match pg().verified_stmt(sql) { Statement::CreateIndex(CreateIndex { name: Some(ObjectName(name)), table_name: ObjectName(table_name), using, columns, unique, concurrently, if_not_exists, include, nulls_distinct: None, with, predicate: None, index_options, alter_options, }) => { assert_eq_vec(&["my_index"], &name); assert_eq_vec(&["my_table"], &table_name); assert_eq!(None, using); assert!(!unique); assert!(!concurrently); assert!(if_not_exists); assert_eq_vec(&["col1", "col2"], &columns); assert_eq_vec(&["col3", "col4"], &include); assert!(with.is_empty()); assert!(index_options.is_empty()); assert!(alter_options.is_empty()); } _ => unreachable!(), } } #[test] fn parse_create_index_with_nulls_distinct() { let sql = "CREATE INDEX IF NOT EXISTS my_index ON my_table(col1, col2) NULLS NOT DISTINCT"; match pg().verified_stmt(sql) { Statement::CreateIndex(CreateIndex { name: Some(ObjectName(name)), table_name: ObjectName(table_name), using, columns, unique, concurrently, if_not_exists, include, nulls_distinct: Some(nulls_distinct), with, predicate: None, index_options, alter_options, }) => { assert_eq_vec(&["my_index"], &name); assert_eq_vec(&["my_table"], &table_name); assert_eq!(None, using); assert!(!unique); assert!(!concurrently); assert!(if_not_exists); assert_eq_vec(&["col1", "col2"], &columns); assert!(include.is_empty()); assert!(!nulls_distinct); assert!(with.is_empty()); assert!(index_options.is_empty()); assert!(alter_options.is_empty()); } _ => unreachable!(), } let sql = "CREATE INDEX IF NOT EXISTS my_index ON my_table(col1, col2) NULLS DISTINCT"; match pg().verified_stmt(sql) { Statement::CreateIndex(CreateIndex { name: Some(ObjectName(name)), table_name: ObjectName(table_name), using, columns, unique, concurrently, if_not_exists, include, nulls_distinct: Some(nulls_distinct), with, predicate: None, index_options, alter_options, }) => { assert_eq_vec(&["my_index"], &name); assert_eq_vec(&["my_table"], &table_name); assert_eq!(None, using); assert!(!unique); assert!(!concurrently); assert!(if_not_exists); assert_eq_vec(&["col1", "col2"], &columns); assert!(include.is_empty()); assert!(nulls_distinct); assert!(with.is_empty()); assert!(index_options.is_empty()); assert!(alter_options.is_empty()); } _ => unreachable!(), } } #[test] fn parse_array_subquery_expr() { let sql = "SELECT ARRAY(SELECT 1 UNION SELECT 2)"; let select = pg().verified_only_select(sql); assert_eq!( &Expr::Function(Function { name: ObjectName::from(vec![Ident::new("ARRAY")]), uses_odbc_syntax: false, parameters: FunctionArguments::None, args: FunctionArguments::Subquery(Box::new(Query { with: None, body: Box::new(SetExpr::SetOperation { op: SetOperator::Union, set_quantifier: SetQuantifier::None, left: Box::new(SetExpr::Select(Box::new(Select { select_token: AttachedToken::empty(), optimizer_hints: vec![], distinct: None, select_modifiers: None, top: None, top_before_distinct: false, projection: vec![SelectItem::UnnamedExpr(Expr::Value( (number("1")).with_empty_span() ))], exclude: None, into: None, from: vec![], lateral_views: vec![], prewhere: None, selection: None, group_by: GroupByExpr::Expressions(vec![], vec![]), cluster_by: vec![], distribute_by: vec![], sort_by: vec![], having: None, named_window: vec![], qualify: None, window_before_qualify: false, value_table_mode: None, connect_by: vec![], flavor: SelectFlavor::Standard, }))), right: Box::new(SetExpr::Select(Box::new(Select { select_token: AttachedToken::empty(), optimizer_hints: vec![], distinct: None, select_modifiers: None, top: None, top_before_distinct: false, projection: vec![SelectItem::UnnamedExpr(Expr::Value( (number("2")).with_empty_span() ))], exclude: None, into: None, from: vec![], lateral_views: vec![], prewhere: None, selection: None, group_by: GroupByExpr::Expressions(vec![], vec![]), cluster_by: vec![], distribute_by: vec![], sort_by: vec![], having: None, named_window: vec![], qualify: None, window_before_qualify: false, value_table_mode: None, connect_by: vec![], flavor: SelectFlavor::Standard, }))), }), order_by: None, limit_clause: None, fetch: None, locks: vec![], for_clause: None, settings: None, format_clause: None, pipe_operators: vec![], })), filter: None, null_treatment: None, over: None, within_group: vec![] }), expr_from_projection(only(&select.projection)), ); } #[test] fn test_transaction_statement() { let statement = pg().verified_stmt("SET TRANSACTION SNAPSHOT '000003A1-1'"); assert_eq!( statement, Statement::Set(Set::SetTransaction { modes: vec![], snapshot: Some(Value::SingleQuotedString(String::from("000003A1-1")).with_empty_span()), session: false }) ); let statement = pg().verified_stmt("SET SESSION CHARACTERISTICS AS TRANSACTION READ ONLY, READ WRITE, ISOLATION LEVEL SERIALIZABLE"); assert_eq!( statement, Statement::Set(Set::SetTransaction { modes: vec![ TransactionMode::AccessMode(TransactionAccessMode::ReadOnly), TransactionMode::AccessMode(TransactionAccessMode::ReadWrite), TransactionMode::IsolationLevel(TransactionIsolationLevel::Serializable), ], snapshot: None, session: true }) ); } #[test] fn test_json() { let sql = "SELECT params ->> 'name' FROM events"; let select = pg().verified_only_select(sql); assert_eq!( SelectItem::UnnamedExpr(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("params"))), op: BinaryOperator::LongArrow, right: Box::new(Expr::Value( (Value::SingleQuotedString("name".to_string())).with_empty_span() )), }), select.projection[0] ); let sql = "SELECT params -> 'name' FROM events"; let select = pg().verified_only_select(sql); assert_eq!( SelectItem::UnnamedExpr(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("params"))), op: BinaryOperator::Arrow, right: Box::new(Expr::Value( (Value::SingleQuotedString("name".to_string())).with_empty_span() )), }), select.projection[0] ); let sql = "SELECT info -> 'items' ->> 'product' FROM orders"; let select = pg().verified_only_select(sql); assert_eq!( SelectItem::UnnamedExpr(Expr::BinaryOp { left: Box::new(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("info"))), op: BinaryOperator::Arrow, right: Box::new(Expr::Value( (Value::SingleQuotedString("items".to_string())).with_empty_span() )) }), op: BinaryOperator::LongArrow, right: Box::new(Expr::Value( (Value::SingleQuotedString("product".to_string())).with_empty_span() )), }), select.projection[0] ); // the RHS can be a number (array element access) let sql = "SELECT obj -> 42"; let select = pg().verified_only_select(sql); assert_eq!( SelectItem::UnnamedExpr(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("obj"))), op: BinaryOperator::Arrow, right: Box::new(Expr::value(number("42"))), }), select.projection[0] ); // the RHS can be an identifier let sql = "SELECT obj -> key"; let select = pg().verified_only_select(sql); assert_eq!( SelectItem::UnnamedExpr(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("obj"))), op: BinaryOperator::Arrow, right: Box::new(Expr::Identifier(Ident::new("key"))), }), select.projection[0] ); // -> operator has lower precedence than arithmetic ops let sql = "SELECT obj -> 3 * 2"; let select = pg().verified_only_select(sql); assert_eq!( SelectItem::UnnamedExpr(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("obj"))), op: BinaryOperator::Arrow, right: Box::new(Expr::BinaryOp { left: Box::new(Expr::value(number("3"))), op: BinaryOperator::Multiply, right: Box::new(Expr::value(number("2"))), }), }), select.projection[0] ); let sql = "SELECT info #> '{a,b,c}' FROM orders"; let select = pg().verified_only_select(sql); assert_eq!( SelectItem::UnnamedExpr(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("info"))), op: BinaryOperator::HashArrow, right: Box::new(Expr::Value( (Value::SingleQuotedString("{a,b,c}".to_string())).with_empty_span() )), }), select.projection[0] ); let sql = "SELECT info #>> '{a,b,c}' FROM orders"; let select = pg().verified_only_select(sql); assert_eq!( SelectItem::UnnamedExpr(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("info"))), op: BinaryOperator::HashLongArrow, right: Box::new(Expr::Value( (Value::SingleQuotedString("{a,b,c}".to_string())).with_empty_span() )), }), select.projection[0] ); let sql = "SELECT info FROM orders WHERE info @> '{\"a\": 1}'"; let select = pg().verified_only_select(sql); assert_eq!( Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("info"))), op: BinaryOperator::AtArrow, right: Box::new(Expr::Value( (Value::SingleQuotedString("{\"a\": 1}".to_string())).with_empty_span() )), }, select.selection.unwrap(), ); let sql = "SELECT info FROM orders WHERE '{\"a\": 1}' <@ info"; let select = pg().verified_only_select(sql); assert_eq!( Expr::BinaryOp { left: Box::new(Expr::Value( (Value::SingleQuotedString("{\"a\": 1}".to_string())).with_empty_span() )), op: BinaryOperator::ArrowAt, right: Box::new(Expr::Identifier(Ident::new("info"))), }, select.selection.unwrap(), ); let sql = "SELECT info #- ARRAY['a', 'b'] FROM orders"; let select = pg().verified_only_select(sql); assert_eq!( SelectItem::UnnamedExpr(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::from("info"))), op: BinaryOperator::HashMinus, right: Box::new(Expr::Array(Array { elem: vec![ Expr::Value((Value::SingleQuotedString("a".to_string())).with_empty_span()), Expr::Value((Value::SingleQuotedString("b".to_string())).with_empty_span()), ], named: true, })), }), select.projection[0], ); let sql = "SELECT info FROM orders WHERE info @? '$.a'"; let select = pg().verified_only_select(sql); assert_eq!( Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::from("info"))), op: BinaryOperator::AtQuestion, right: Box::new(Expr::Value( (Value::SingleQuotedString("$.a".to_string())).with_empty_span() ),), }, select.selection.unwrap(), ); let sql = "SELECT info FROM orders WHERE info @@ '$.a'"; let select = pg().verified_only_select(sql); assert_eq!( Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::from("info"))), op: BinaryOperator::AtAt, right: Box::new(Expr::Value( (Value::SingleQuotedString("$.a".to_string())).with_empty_span() ),), }, select.selection.unwrap(), ); let sql = r#"SELECT info FROM orders WHERE info ? 'b'"#; let select = pg().verified_only_select(sql); assert_eq!( Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("info"))), op: BinaryOperator::Question, right: Box::new(Expr::Value( (Value::SingleQuotedString("b".to_string())).with_empty_span() )), }, select.selection.unwrap(), ); let sql = r#"SELECT info FROM orders WHERE info ?& ARRAY['b', 'c']"#; let select = pg().verified_only_select(sql); assert_eq!( Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("info"))), op: BinaryOperator::QuestionAnd, right: Box::new(Expr::Array(Array { elem: vec![ Expr::Value((Value::SingleQuotedString("b".to_string())).with_empty_span()), Expr::Value((Value::SingleQuotedString("c".to_string())).with_empty_span()) ], named: true })) }, select.selection.unwrap(), ); let sql = r#"SELECT info FROM orders WHERE info ?| ARRAY['b', 'c']"#; let select = pg().verified_only_select(sql); assert_eq!( Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("info"))), op: BinaryOperator::QuestionPipe, right: Box::new(Expr::Array(Array { elem: vec![ Expr::Value((Value::SingleQuotedString("b".to_string())).with_empty_span()), Expr::Value((Value::SingleQuotedString("c".to_string())).with_empty_span()) ], named: true })) }, select.selection.unwrap(), ); } #[test] fn json_object_colon_syntax() { match pg().verified_expr("JSON_OBJECT('name' : 'value')") { Expr::Function(Function { args: FunctionArguments::List(FunctionArgumentList { args, .. }), .. }) => { assert!( matches!( &args[..], &[FunctionArg::ExprNamed { operator: FunctionArgOperator::Colon, .. }] ), "Invalid function argument: {args:?}" ); } other => panic!( "Expected: JSON_OBJECT('name' : 'value') to be parsed as a function, but got {other:?}" ), } } #[test] fn json_object_value_syntax() { match pg().verified_expr("JSON_OBJECT('name' VALUE 'value')") { Expr::Function(Function { args: FunctionArguments::List(FunctionArgumentList { args, .. }), .. }) => { assert!(matches!( &args[..], &[FunctionArg::ExprNamed { operator: FunctionArgOperator::Value, .. }] ), "Invalid function argument: {args:?}"); } other => panic!("Expected: JSON_OBJECT('name' VALUE 'value') to be parsed as a function, but got {other:?}"), } } #[test] fn parse_json_object() { let sql = "JSON_OBJECT('name' VALUE 'value' NULL ON NULL)"; let expr = pg().verified_expr(sql); assert!( matches!( expr.clone(), Expr::Function(Function { name: ObjectName(parts), args: FunctionArguments::List(FunctionArgumentList { args, clauses, .. }), .. }) if parts == vec![ObjectNamePart::Identifier(Ident::new("JSON_OBJECT"))] && matches!( &args[..], &[FunctionArg::ExprNamed { operator: FunctionArgOperator::Value, .. }] ) && clauses == vec![FunctionArgumentClause::JsonNullClause(JsonNullClause::NullOnNull)] ), "Failed to parse JSON_OBJECT with expected structure, got: {expr:?}" ); let sql = "JSON_OBJECT('name' VALUE 'value' RETURNING JSONB)"; let expr = pg().verified_expr(sql); assert!( matches!( expr.clone(), Expr::Function(Function { name: ObjectName(parts), args: FunctionArguments::List(FunctionArgumentList { args, clauses, .. }), .. }) if parts == vec![ObjectNamePart::Identifier(Ident::new("JSON_OBJECT"))] && matches!( &args[..], &[FunctionArg::ExprNamed { operator: FunctionArgOperator::Value, .. }] ) && clauses == vec![FunctionArgumentClause::JsonReturningClause(JsonReturningClause { data_type: DataType::JSONB })] ), "Failed to parse JSON_OBJECT with expected structure, got: {expr:?}" ); let sql = "JSON_OBJECT(RETURNING JSONB)"; let expr = pg().verified_expr(sql); assert!( matches!( expr.clone(), Expr::Function(Function { name: ObjectName(parts), args: FunctionArguments::List(FunctionArgumentList { args, clauses, .. }), .. }) if parts == vec![ObjectNamePart::Identifier(Ident::new("JSON_OBJECT"))] && args.is_empty() && clauses == vec![FunctionArgumentClause::JsonReturningClause(JsonReturningClause { data_type: DataType::JSONB })] ), "Failed to parse JSON_OBJECT with expected structure, got: {expr:?}" ); } #[test] fn parse_json_table_is_not_reserved() { // JSON_TABLE is not a reserved keyword in PostgreSQL, even though it is in SQL:2023 // see: https://en.wikipedia.org/wiki/List_of_SQL_reserved_words let Select { from, .. } = pg_and_generic().verified_only_select("SELECT * FROM JSON_TABLE"); assert_eq!(1, from.len()); match &from[0].relation { TableFactor::Table { name: ObjectName(name), .. } => assert_eq!( ObjectNamePart::Identifier(Ident::new("JSON_TABLE")), name[0] ), other => panic!("Expected: JSON_TABLE to be parsed as a table name, but got {other:?}"), } } #[test] fn test_composite_value() { let sql = "SELECT (on_hand.item).name FROM on_hand WHERE (on_hand.item).price > 9"; let select = pg().verified_only_select(sql); let Expr::CompoundFieldAccess { root, access_chain } = expr_from_projection(&select.projection[0]) else { unreachable!("expected projection: got {:?}", &select.projection[0]); }; assert_eq!( root.as_ref(), &Expr::Nested(Box::new(Expr::CompoundIdentifier(vec![ Ident::new("on_hand"), Ident::new("item") ]))) ); assert_eq!( access_chain.as_slice(), &[AccessExpr::Dot(Expr::Identifier(Ident::new("name")))] ); assert_eq!( select.selection.as_ref().unwrap(), &Expr::BinaryOp { left: Box::new(Expr::CompoundFieldAccess { root: Expr::Nested(Box::new(Expr::CompoundIdentifier(vec![ Ident::new("on_hand"), Ident::new("item") ]))) .into(), access_chain: vec![AccessExpr::Dot(Expr::Identifier(Ident::new("price")))] }), op: BinaryOperator::Gt, right: Box::new(Expr::value(number("9"))) } ); let sql = "SELECT (information_schema._pg_expandarray(ARRAY['i', 'i'])).n"; let select = pg().verified_only_select(sql); assert_eq!( &Expr::CompoundFieldAccess { root: Box::new(Expr::Nested(Box::new(Expr::Function(Function { name: ObjectName::from(vec![ Ident::new("information_schema"), Ident::new("_pg_expandarray") ]), uses_odbc_syntax: false, parameters: FunctionArguments::None, args: FunctionArguments::List(FunctionArgumentList { duplicate_treatment: None, args: vec![FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::Array( Array { elem: vec![ Expr::Value( (Value::SingleQuotedString("i".to_string())).with_empty_span() ), Expr::Value( (Value::SingleQuotedString("i".to_string())).with_empty_span() ), ], named: true } )))], clauses: vec![], }), null_treatment: None, filter: None, over: None, within_group: vec![], })))), access_chain: vec![AccessExpr::Dot(Expr::Identifier(Ident::new("n")))], }, expr_from_projection(&select.projection[0]) ); } #[test] fn parse_quoted_identifier() { pg_and_generic().verified_stmt(r#"SELECT "quoted "" ident""#); } #[test] fn parse_quoted_identifier_2() { pg_and_generic().verified_stmt(r#"SELECT """quoted ident""""#); } #[test] fn parse_local_and_global() { pg_and_generic().verified_stmt("CREATE LOCAL TEMPORARY TABLE table (COL INT)"); } #[test] fn parse_on_commit() { pg_and_generic() .verified_stmt("CREATE TEMPORARY TABLE table (COL INT) ON COMMIT PRESERVE ROWS"); pg_and_generic().verified_stmt("CREATE TEMPORARY TABLE table (COL INT) ON COMMIT DELETE ROWS"); pg_and_generic().verified_stmt("CREATE TEMPORARY TABLE table (COL INT) ON COMMIT DROP"); } #[test] fn parse_xml_typed_string() { // xml '...' should parse as a TypedString on PostgreSQL and Generic let sql = "SELECT xml ''"; let select = pg_and_generic().verified_only_select(sql); match expr_from_projection(&select.projection[0]) { Expr::TypedString(TypedString { data_type: DataType::Custom(name, modifiers), value, uses_odbc_syntax: false, }) => { assert_eq!(name.to_string(), "xml"); assert!(modifiers.is_empty()); assert_eq!(value.value, Value::SingleQuotedString("".to_string())); } other => panic!("Expected TypedString, got: {other:?}"), } } fn pg() -> TestedDialects { TestedDialects::new(vec![Box::new(PostgreSqlDialect {})]) } fn pg_and_generic() -> TestedDialects { TestedDialects::new(vec![ Box::new(PostgreSqlDialect {}), Box::new(GenericDialect {}), ]) } #[test] fn parse_escaped_literal_string() { let sql = r"SELECT E's1 \n s1', E's2 \\n s2', E's3 \\\n s3', E's4 \\\\n s4', E'\'', E'foo \\'"; let select = pg_and_generic().verified_only_select(sql); assert_eq!(6, select.projection.len()); assert_eq!( &Expr::Value((Value::EscapedStringLiteral("s1 \n s1".to_string())).with_empty_span()), expr_from_projection(&select.projection[0]) ); assert_eq!( &Expr::Value((Value::EscapedStringLiteral("s2 \\n s2".to_string())).with_empty_span()), expr_from_projection(&select.projection[1]) ); assert_eq!( &Expr::Value((Value::EscapedStringLiteral("s3 \\\n s3".to_string())).with_empty_span()), expr_from_projection(&select.projection[2]) ); assert_eq!( &Expr::Value((Value::EscapedStringLiteral("s4 \\\\n s4".to_string())).with_empty_span()), expr_from_projection(&select.projection[3]) ); assert_eq!( &Expr::Value((Value::EscapedStringLiteral("'".to_string())).with_empty_span()), expr_from_projection(&select.projection[4]) ); assert_eq!( &Expr::Value((Value::EscapedStringLiteral("foo \\".to_string())).with_empty_span()), expr_from_projection(&select.projection[5]) ); let sql = r"SELECT E'\'"; assert_eq!( pg_and_generic() .parse_sql_statements(sql) .unwrap_err() .to_string(), "sql parser error: Unterminated encoded string literal at Line: 1, Column: 8" ); let sql = r"SELECT E'\u0001', E'\U0010FFFF', E'\xC', E'\x25', E'\2', E'\45', E'\445'"; let canonical = ""; let select = pg_and_generic().verified_only_select_with_canonical(sql, canonical); assert_eq!(7, select.projection.len()); assert_eq!( &Expr::Value((Value::EscapedStringLiteral("\u{0001}".to_string())).with_empty_span()), expr_from_projection(&select.projection[0]) ); assert_eq!( &Expr::Value((Value::EscapedStringLiteral("\u{10ffff}".to_string())).with_empty_span()), expr_from_projection(&select.projection[1]) ); assert_eq!( &Expr::Value((Value::EscapedStringLiteral("\u{000c}".to_string())).with_empty_span()), expr_from_projection(&select.projection[2]) ); assert_eq!( &Expr::Value((Value::EscapedStringLiteral("%".to_string())).with_empty_span()), expr_from_projection(&select.projection[3]) ); assert_eq!( &Expr::Value((Value::EscapedStringLiteral("\u{0002}".to_string())).with_empty_span()), expr_from_projection(&select.projection[4]) ); assert_eq!( &Expr::Value((Value::EscapedStringLiteral("%".to_string())).with_empty_span()), expr_from_projection(&select.projection[5]) ); assert_eq!( &Expr::Value((Value::EscapedStringLiteral("%".to_string())).with_empty_span()), expr_from_projection(&select.projection[6]) ); fn negative_cast(sqls: &[&str]) { for sql in sqls { assert_eq!( pg_and_generic() .parse_sql_statements(sql) .unwrap_err() .to_string(), "sql parser error: Unterminated encoded string literal at Line: 1, Column: 8" ); } } negative_cast(&[ r"SELECT E'\u0000'", r"SELECT E'\U00110000'", r"SELECT E'\u{0001}'", r"SELECT E'\xCAD'", r"SELECT E'\080'", ]); } #[test] fn parse_declare() { pg_and_generic() .verified_stmt("DECLARE \"SQL_CUR0x7fa44801bc00\" CURSOR WITH HOLD FOR SELECT 1"); pg_and_generic() .verified_stmt("DECLARE \"SQL_CUR0x7fa44801bc00\" CURSOR WITHOUT HOLD FOR SELECT 1"); pg_and_generic().verified_stmt("DECLARE \"SQL_CUR0x7fa44801bc00\" BINARY CURSOR FOR SELECT 1"); pg_and_generic() .verified_stmt("DECLARE \"SQL_CUR0x7fa44801bc00\" ASENSITIVE CURSOR FOR SELECT 1"); pg_and_generic() .verified_stmt("DECLARE \"SQL_CUR0x7fa44801bc00\" INSENSITIVE CURSOR FOR SELECT 1"); pg_and_generic().verified_stmt("DECLARE \"SQL_CUR0x7fa44801bc00\" SCROLL CURSOR FOR SELECT 1"); pg_and_generic() .verified_stmt("DECLARE \"SQL_CUR0x7fa44801bc00\" NO SCROLL CURSOR FOR SELECT 1"); pg_and_generic().verified_stmt("DECLARE \"SQL_CUR0x7fa44801bc00\" BINARY INSENSITIVE SCROLL CURSOR WITH HOLD FOR SELECT * FROM table_name LIMIT 2222"); } #[test] fn parse_current_functions() { let sql = "SELECT CURRENT_CATALOG, CURRENT_USER, SESSION_USER, USER"; let select = pg_and_generic().verified_only_select(sql); assert_eq!( &Expr::Function(Function { name: ObjectName::from(vec![Ident::new("CURRENT_CATALOG")]), uses_odbc_syntax: false, parameters: FunctionArguments::None, args: FunctionArguments::None, null_treatment: None, filter: None, over: None, within_group: vec![], }), expr_from_projection(&select.projection[0]) ); assert_eq!( &Expr::Function(Function { name: ObjectName::from(vec![Ident::new("CURRENT_USER")]), uses_odbc_syntax: false, parameters: FunctionArguments::None, args: FunctionArguments::None, null_treatment: None, filter: None, over: None, within_group: vec![], }), expr_from_projection(&select.projection[1]) ); assert_eq!( &Expr::Function(Function { name: ObjectName::from(vec![Ident::new("SESSION_USER")]), uses_odbc_syntax: false, parameters: FunctionArguments::None, args: FunctionArguments::None, null_treatment: None, filter: None, over: None, within_group: vec![], }), expr_from_projection(&select.projection[2]) ); assert_eq!( &Expr::Function(Function { name: ObjectName::from(vec![Ident::new("USER")]), uses_odbc_syntax: false, parameters: FunctionArguments::None, args: FunctionArguments::None, null_treatment: None, filter: None, over: None, within_group: vec![], }), expr_from_projection(&select.projection[3]) ); } #[test] fn parse_fetch() { pg_and_generic().verified_stmt("FETCH 2048 IN \"SQL_CUR0x7fa44801bc00\""); pg_and_generic().verified_stmt("FETCH 2048 IN \"SQL_CUR0x7fa44801bc00\" INTO \"new_table\""); pg_and_generic().verified_stmt("FETCH NEXT IN \"SQL_CUR0x7fa44801bc00\" INTO \"new_table\""); pg_and_generic().verified_stmt("FETCH PRIOR IN \"SQL_CUR0x7fa44801bc00\" INTO \"new_table\""); pg_and_generic().verified_stmt("FETCH FIRST IN \"SQL_CUR0x7fa44801bc00\" INTO \"new_table\""); pg_and_generic().verified_stmt("FETCH LAST IN \"SQL_CUR0x7fa44801bc00\" INTO \"new_table\""); pg_and_generic() .verified_stmt("FETCH ABSOLUTE 2048 IN \"SQL_CUR0x7fa44801bc00\" INTO \"new_table\""); pg_and_generic() .verified_stmt("FETCH RELATIVE 2048 IN \"SQL_CUR0x7fa44801bc00\" INTO \"new_table\""); pg_and_generic().verified_stmt("FETCH ALL IN \"SQL_CUR0x7fa44801bc00\" INTO \"new_table\""); pg_and_generic().verified_stmt("FETCH ALL IN \"SQL_CUR0x7fa44801bc00\" INTO \"new_table\""); pg_and_generic() .verified_stmt("FETCH FORWARD 2048 IN \"SQL_CUR0x7fa44801bc00\" INTO \"new_table\""); pg_and_generic() .verified_stmt("FETCH FORWARD ALL IN \"SQL_CUR0x7fa44801bc00\" INTO \"new_table\""); pg_and_generic() .verified_stmt("FETCH BACKWARD 2048 IN \"SQL_CUR0x7fa44801bc00\" INTO \"new_table\""); pg_and_generic() .verified_stmt("FETCH BACKWARD ALL IN \"SQL_CUR0x7fa44801bc00\" INTO \"new_table\""); } #[test] fn parse_custom_operator() { // operator with a database and schema let sql = r#"SELECT * FROM events WHERE relname OPERATOR(database.pg_catalog.~) '^(table)$'"#; let select = pg().verified_only_select(sql); assert_eq!( select.selection, Some(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident { value: "relname".into(), quote_style: None, span: Span::empty(), })), op: BinaryOperator::PGCustomBinaryOperator(vec![ "database".into(), "pg_catalog".into(), "~".into() ]), right: Box::new(Expr::Value( (Value::SingleQuotedString("^(table)$".into())).with_empty_span() )) }) ); // operator with a schema let sql = r#"SELECT * FROM events WHERE relname OPERATOR(pg_catalog.~) '^(table)$'"#; let select = pg().verified_only_select(sql); assert_eq!( select.selection, Some(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident { value: "relname".into(), quote_style: None, span: Span::empty(), })), op: BinaryOperator::PGCustomBinaryOperator(vec!["pg_catalog".into(), "~".into()]), right: Box::new(Expr::Value( (Value::SingleQuotedString("^(table)$".into())).with_empty_span() )) }) ); // custom operator without a schema let sql = r#"SELECT * FROM events WHERE relname OPERATOR(~) '^(table)$'"#; let select = pg().verified_only_select(sql); assert_eq!( select.selection, Some(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident { value: "relname".into(), quote_style: None, span: Span::empty(), })), op: BinaryOperator::PGCustomBinaryOperator(vec!["~".into()]), right: Box::new(Expr::Value( (Value::SingleQuotedString("^(table)$".into())).with_empty_span() )) }) ); } #[test] fn parse_create_role() { let sql = "CREATE ROLE IF NOT EXISTS mysql_a, mysql_b"; match pg().verified_stmt(sql) { Statement::CreateRole(create_role) => { assert_eq_vec(&["mysql_a", "mysql_b"], &create_role.names); assert!(create_role.if_not_exists); } _ => unreachable!(), } let sql = "CREATE ROLE abc LOGIN PASSWORD NULL"; match pg().parse_sql_statements(sql).as_deref() { Ok([Statement::CreateRole(create_role)]) => { assert_eq_vec(&["abc"], &create_role.names); assert_eq!(create_role.login, Some(true)); assert_eq!(create_role.password, Some(Password::NullPassword)); } err => panic!("Failed to parse CREATE ROLE test case: {err:?}"), } let sql = "CREATE ROLE abc WITH LOGIN PASSWORD NULL"; match pg().parse_sql_statements(sql).as_deref() { Ok([Statement::CreateRole(create_role)]) => { assert_eq_vec(&["abc"], &create_role.names); assert_eq!(create_role.login, Some(true)); assert_eq!(create_role.password, Some(Password::NullPassword)); } err => panic!("Failed to parse CREATE ROLE test case: {err:?}"), } let sql = "CREATE ROLE magician WITH SUPERUSER CREATEROLE NOCREATEDB BYPASSRLS INHERIT PASSWORD 'abcdef' LOGIN VALID UNTIL '2025-01-01' IN ROLE role1, role2 ROLE role3 ADMIN role4, role5 REPLICATION"; // Roundtrip order of optional parameters is not preserved match pg().parse_sql_statements(sql).as_deref() { Ok([Statement::CreateRole(create_role)]) => { assert_eq_vec(&["magician"], &create_role.names); assert!(!create_role.if_not_exists); assert_eq!(create_role.login, Some(true)); assert_eq!(create_role.inherit, Some(true)); assert_eq!(create_role.bypassrls, Some(true)); assert_eq!( create_role.password, Some(Password::Password(Expr::Value( (Value::SingleQuotedString("abcdef".into())).with_empty_span() ))) ); assert_eq!(create_role.superuser, Some(true)); assert_eq!(create_role.create_db, Some(false)); assert_eq!(create_role.create_role, Some(true)); assert_eq!(create_role.replication, Some(true)); assert_eq!(create_role.connection_limit, None); assert_eq!( create_role.valid_until, Some(Expr::Value( (Value::SingleQuotedString("2025-01-01".into())).with_empty_span() )) ); assert_eq_vec(&["role1", "role2"], &create_role.in_role); assert!(create_role.in_group.is_empty()); assert_eq_vec(&["role3"], &create_role.role); assert_eq_vec(&["role4", "role5"], &create_role.admin); assert_eq!(create_role.authorization_owner, None); } err => panic!("Failed to parse CREATE ROLE test case: {err:?}"), } let sql = "CREATE ROLE abc WITH USER foo, bar ROLE baz "; match pg().parse_sql_statements(sql).as_deref() { Ok([Statement::CreateRole(create_role)]) => { assert_eq_vec(&["abc"], &create_role.names); assert_eq_vec(&["foo", "bar"], &create_role.user); assert_eq_vec(&["baz"], &create_role.role); } err => panic!("Failed to parse CREATE ROLE test case: {err:?}"), } let negatables = [ "BYPASSRLS", "CREATEDB", "CREATEROLE", "INHERIT", "LOGIN", "REPLICATION", "SUPERUSER", ]; for negatable_kw in negatables.iter() { let sql = format!("CREATE ROLE abc {negatable_kw} NO{negatable_kw}"); if pg().parse_sql_statements(&sql).is_ok() { panic!("Should not be able to parse CREATE ROLE containing both negated and non-negated versions of the same keyword: {negatable_kw}") } } } #[test] fn parse_alter_role() { let sql = "ALTER ROLE old_name RENAME TO new_name"; assert_eq!( pg().verified_stmt(sql), Statement::AlterRole { name: Ident { value: "old_name".into(), quote_style: None, span: Span::empty(), }, operation: AlterRoleOperation::RenameRole { role_name: Ident { value: "new_name".into(), quote_style: None, span: Span::empty(), } }, } ); let sql = "ALTER ROLE role_name WITH SUPERUSER CREATEDB CREATEROLE INHERIT LOGIN REPLICATION BYPASSRLS CONNECTION LIMIT 100 PASSWORD 'abcdef' VALID UNTIL '2025-01-01'"; assert_eq!( pg().verified_stmt(sql), Statement::AlterRole { name: Ident { value: "role_name".into(), quote_style: None, span: Span::empty(), }, operation: AlterRoleOperation::WithOptions { options: vec![ RoleOption::SuperUser(true), RoleOption::CreateDB(true), RoleOption::CreateRole(true), RoleOption::Inherit(true), RoleOption::Login(true), RoleOption::Replication(true), RoleOption::BypassRLS(true), RoleOption::ConnectionLimit(Expr::value(number("100"))), RoleOption::Password({ Password::Password(Expr::Value( (Value::SingleQuotedString("abcdef".into())).with_empty_span(), )) }), RoleOption::ValidUntil(Expr::Value( (Value::SingleQuotedString("2025-01-01".into(),)).with_empty_span() )) ] }, } ); let sql = "ALTER ROLE role_name WITH NOSUPERUSER NOCREATEDB NOCREATEROLE NOINHERIT NOLOGIN NOREPLICATION NOBYPASSRLS PASSWORD NULL"; assert_eq!( pg().verified_stmt(sql), Statement::AlterRole { name: Ident { value: "role_name".into(), quote_style: None, span: Span::empty(), }, operation: AlterRoleOperation::WithOptions { options: vec![ RoleOption::SuperUser(false), RoleOption::CreateDB(false), RoleOption::CreateRole(false), RoleOption::Inherit(false), RoleOption::Login(false), RoleOption::Replication(false), RoleOption::BypassRLS(false), RoleOption::Password(Password::NullPassword), ] }, } ); let sql = "ALTER ROLE role_name SET maintenance_work_mem FROM CURRENT"; assert_eq!( pg().verified_stmt(sql), Statement::AlterRole { name: Ident { value: "role_name".into(), quote_style: None, span: Span::empty(), }, operation: AlterRoleOperation::Set { config_name: ObjectName::from(vec![Ident { value: "maintenance_work_mem".into(), quote_style: None, span: Span::empty(), }]), config_value: SetConfigValue::FromCurrent, in_database: None }, } ); let sql = "ALTER ROLE role_name IN DATABASE database_name SET maintenance_work_mem = 100000"; assert_eq!( pg().parse_sql_statements(sql).unwrap(), [Statement::AlterRole { name: Ident { value: "role_name".into(), quote_style: None, span: Span::empty(), }, operation: AlterRoleOperation::Set { config_name: ObjectName::from(vec![Ident { value: "maintenance_work_mem".into(), quote_style: None, span: Span::empty(), }]), config_value: SetConfigValue::Value(Expr::Value( (number("100000")).with_empty_span() )), in_database: Some(ObjectName::from(vec![Ident { value: "database_name".into(), quote_style: None, span: Span::empty(), }])) }, }] ); let sql = "ALTER ROLE role_name IN DATABASE database_name SET maintenance_work_mem TO 100000"; assert_eq!( pg().verified_stmt(sql), Statement::AlterRole { name: Ident { value: "role_name".into(), quote_style: None, span: Span::empty(), }, operation: AlterRoleOperation::Set { config_name: ObjectName::from(vec![Ident { value: "maintenance_work_mem".into(), quote_style: None, span: Span::empty(), }]), config_value: SetConfigValue::Value(Expr::Value( (number("100000")).with_empty_span() )), in_database: Some(ObjectName::from(vec![Ident { value: "database_name".into(), quote_style: None, span: Span::empty(), }])) }, } ); let sql = "ALTER ROLE role_name IN DATABASE database_name SET maintenance_work_mem TO DEFAULT"; assert_eq!( pg().verified_stmt(sql), Statement::AlterRole { name: Ident { value: "role_name".into(), quote_style: None, span: Span::empty(), }, operation: AlterRoleOperation::Set { config_name: ObjectName::from(vec![Ident { value: "maintenance_work_mem".into(), quote_style: None, span: Span::empty(), }]), config_value: SetConfigValue::Default, in_database: Some(ObjectName::from(vec![Ident { value: "database_name".into(), quote_style: None, span: Span::empty(), }])) }, } ); let sql = "ALTER ROLE role_name RESET ALL"; assert_eq!( pg().verified_stmt(sql), Statement::AlterRole { name: Ident { value: "role_name".into(), quote_style: None, span: Span::empty(), }, operation: AlterRoleOperation::Reset { config_name: ResetConfig::ALL, in_database: None }, } ); let sql = "ALTER ROLE role_name IN DATABASE database_name RESET maintenance_work_mem"; assert_eq!( pg().verified_stmt(sql), Statement::AlterRole { name: Ident { value: "role_name".into(), quote_style: None, span: Span::empty(), }, operation: AlterRoleOperation::Reset { config_name: ResetConfig::ConfigName(ObjectName::from(vec![Ident { value: "maintenance_work_mem".into(), quote_style: None, span: Span::empty(), }])), in_database: Some(ObjectName::from(vec![Ident { value: "database_name".into(), quote_style: None, span: Span::empty(), }])) }, } ); } #[test] fn parse_delimited_identifiers() { // check that quoted identifiers in any position remain quoted after serialization let select = pg().verified_only_select( r#"SELECT "alias"."bar baz", "myfun"(), "simple id" AS "column alias" FROM "a table" AS "alias""#, ); // check FROM match only(select.from).relation { TableFactor::Table { name, alias, args, with_hints, version, .. } => { assert_eq!( ObjectName::from(vec![Ident::with_quote('"', "a table")]), name ); assert_eq!(Ident::with_quote('"', "alias"), alias.unwrap().name); assert!(args.is_none()); assert!(with_hints.is_empty()); assert!(version.is_none()); } _ => panic!("Expecting TableFactor::Table"), } // check SELECT assert_eq!(3, select.projection.len()); assert_eq!( &Expr::CompoundIdentifier(vec![ Ident::with_quote('"', "alias"), Ident::with_quote('"', "bar baz"), ]), expr_from_projection(&select.projection[0]), ); assert_eq!( &Expr::Function(Function { name: ObjectName::from(vec![Ident::with_quote('"', "myfun")]), uses_odbc_syntax: false, parameters: FunctionArguments::None, args: FunctionArguments::List(FunctionArgumentList { duplicate_treatment: None, args: vec![], clauses: vec![], }), null_treatment: None, filter: None, over: None, within_group: vec![], }), expr_from_projection(&select.projection[1]), ); match &select.projection[2] { SelectItem::ExprWithAlias { expr, alias } => { assert_eq!(&Expr::Identifier(Ident::with_quote('"', "simple id")), expr); assert_eq!(&Ident::with_quote('"', "column alias"), alias); } _ => panic!("Expected: ExprWithAlias"), } pg().verified_stmt(r#"CREATE TABLE "foo" ("bar" "int")"#); pg().verified_stmt(r#"ALTER TABLE foo ADD CONSTRAINT "bar" PRIMARY KEY (baz)"#); pg().verified_stmt(r#"UPDATE foo SET "bar" = 5"#); } #[test] fn parse_update_has_keyword() { pg().one_statement_parses_to( r#"UPDATE test SET name=$1, value=$2, where=$3, create=$4, is_default=$5, classification=$6, sort=$7 WHERE id=$8"#, r#"UPDATE test SET name = $1, value = $2, where = $3, create = $4, is_default = $5, classification = $6, sort = $7 WHERE id = $8"# ); } #[test] fn parse_update_in_with_subquery() { pg_and_generic().verified_stmt(r#"WITH "result" AS (UPDATE "Hero" SET "name" = 'Captain America', "number_of_movies" = "number_of_movies" + 1 WHERE "secret_identity" = 'Sam Wilson' RETURNING "id", "name", "secret_identity", "number_of_movies") SELECT * FROM "result""#); } #[test] fn parser_create_function_with_args() { let sql1 = r#"CREATE OR REPLACE FUNCTION check_strings_different(str1 VARCHAR, str2 VARCHAR) RETURNS BOOLEAN LANGUAGE plpgsql AS $$ BEGIN IF str1 <> str2 THEN RETURN TRUE; ELSE RETURN FALSE; END IF; END; $$"#; assert_eq!( pg_and_generic().verified_stmt(sql1), Statement::CreateFunction(CreateFunction { or_alter: false, or_replace: true, temporary: false, name: ObjectName::from(vec![Ident::new("check_strings_different")]), args: Some(vec![ OperateFunctionArg::with_name( "str1", DataType::Varchar(None), ), OperateFunctionArg::with_name( "str2", DataType::Varchar(None), ), ]), return_type: Some(FunctionReturnType::DataType(DataType::Boolean)), language: Some("plpgsql".into()), behavior: None, called_on_null: None, parallel: None, security: None, set_params: vec![], function_body: Some(CreateFunctionBody::AsBeforeOptions { body: Expr::Value( (Value::DollarQuotedString(DollarQuotedString {value: "\nBEGIN\n IF str1 <> str2 THEN\n RETURN TRUE;\n ELSE\n RETURN FALSE;\n END IF;\nEND;\n".to_owned(), tag: None})).with_empty_span() ), link_symbol: None, }), if_not_exists: false, using: None, determinism_specifier: None, options: None, remote_connection: None, }) ); let sql2 = r#"CREATE OR REPLACE FUNCTION check_not_zero(int1 INT) RETURNS BOOLEAN LANGUAGE plpgsql AS $$ BEGIN IF int1 <> 0 THEN RETURN TRUE; ELSE RETURN FALSE; END IF; END; $$"#; assert_eq!( pg_and_generic().verified_stmt(sql2), Statement::CreateFunction(CreateFunction { or_alter: false, or_replace: true, temporary: false, name: ObjectName::from(vec![Ident::new("check_not_zero")]), args: Some(vec![ OperateFunctionArg::with_name( "int1", DataType::Int(None) ) ]), return_type: Some(FunctionReturnType::DataType(DataType::Boolean)), language: Some("plpgsql".into()), behavior: None, called_on_null: None, parallel: None, security: None, set_params: vec![], function_body: Some(CreateFunctionBody::AsBeforeOptions { body: Expr::Value( (Value::DollarQuotedString(DollarQuotedString {value: "\nBEGIN\n IF int1 <> 0 THEN\n RETURN TRUE;\n ELSE\n RETURN FALSE;\n END IF;\nEND;\n".to_owned(), tag: None})).with_empty_span() ), link_symbol: None, }), if_not_exists: false, using: None, determinism_specifier: None, options: None, remote_connection: None, }) ); let sql3 = r#"CREATE OR REPLACE FUNCTION check_values_different(a INT, b INT) RETURNS BOOLEAN LANGUAGE plpgsql AS $$ BEGIN IF a <> b THEN RETURN TRUE; ELSE RETURN FALSE; END IF; END; $$"#; assert_eq!( pg_and_generic().verified_stmt(sql3), Statement::CreateFunction(CreateFunction { or_alter: false, or_replace: true, temporary: false, name: ObjectName::from(vec![Ident::new("check_values_different")]), args: Some(vec![ OperateFunctionArg::with_name( "a", DataType::Int(None) ), OperateFunctionArg::with_name( "b", DataType::Int(None) ), ]), return_type: Some(FunctionReturnType::DataType(DataType::Boolean)), language: Some("plpgsql".into()), behavior: None, called_on_null: None, parallel: None, security: None, set_params: vec![], function_body: Some(CreateFunctionBody::AsBeforeOptions { body: Expr::Value( (Value::DollarQuotedString(DollarQuotedString {value: "\nBEGIN\n IF a <> b THEN\n RETURN TRUE;\n ELSE\n RETURN FALSE;\n END IF;\nEND;\n".to_owned(), tag: None})).with_empty_span() ), link_symbol: None, }), if_not_exists: false, using: None, determinism_specifier: None, options: None, remote_connection: None, }) ); let sql4 = r#"CREATE OR REPLACE FUNCTION check_values_different(int1 INT, int2 INT) RETURNS BOOLEAN LANGUAGE plpgsql AS $$ BEGIN IF int1 <> int2 THEN RETURN TRUE; ELSE RETURN FALSE; END IF; END; $$"#; assert_eq!( pg_and_generic().verified_stmt(sql4), Statement::CreateFunction(CreateFunction { or_alter: false, or_replace: true, temporary: false, name: ObjectName::from(vec![Ident::new("check_values_different")]), args: Some(vec![ OperateFunctionArg::with_name( "int1", DataType::Int(None) ), OperateFunctionArg::with_name( "int2", DataType::Int(None) ), ]), return_type: Some(FunctionReturnType::DataType(DataType::Boolean)), language: Some("plpgsql".into()), behavior: None, called_on_null: None, parallel: None, security: None, set_params: vec![], function_body: Some(CreateFunctionBody::AsBeforeOptions { body: Expr::Value( (Value::DollarQuotedString(DollarQuotedString {value: "\nBEGIN\n IF int1 <> int2 THEN\n RETURN TRUE;\n ELSE\n RETURN FALSE;\n END IF;\nEND;\n".to_owned(), tag: None})).with_empty_span() ), link_symbol: None, }), if_not_exists: false, using: None, determinism_specifier: None, options: None, remote_connection: None, }) ); let sql5 = r#"CREATE OR REPLACE FUNCTION foo(a TIMESTAMP WITH TIME ZONE, b VARCHAR) RETURNS BOOLEAN LANGUAGE plpgsql AS $$ BEGIN RETURN TRUE; END; $$"#; assert_eq!( pg_and_generic().verified_stmt(sql5), Statement::CreateFunction(CreateFunction { or_alter: false, or_replace: true, temporary: false, name: ObjectName::from(vec![Ident::new("foo")]), args: Some(vec![ OperateFunctionArg::with_name( "a", DataType::Timestamp(None, TimezoneInfo::WithTimeZone) ), OperateFunctionArg::with_name("b", DataType::Varchar(None)), ]), return_type: Some(FunctionReturnType::DataType(DataType::Boolean)), language: Some("plpgsql".into()), behavior: None, called_on_null: None, parallel: None, security: None, set_params: vec![], function_body: Some(CreateFunctionBody::AsBeforeOptions { body: Expr::Value( (Value::DollarQuotedString(DollarQuotedString { value: "\n BEGIN\n RETURN TRUE;\n END;\n ".to_owned(), tag: None })) .with_empty_span() ), link_symbol: None, }), if_not_exists: false, using: None, determinism_specifier: None, options: None, remote_connection: None, }) ); let incorrect_sql = "CREATE FUNCTION add(function(struct int64), b INTEGER) RETURNS INTEGER LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE AS 'select $1 + $2;'"; assert!(pg().parse_sql_statements(incorrect_sql).is_err(),); } #[test] fn parse_create_function() { let sql = "CREATE FUNCTION add(INTEGER, INTEGER) RETURNS INTEGER LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE AS 'select $1 + $2;'"; assert_eq!( pg_and_generic().verified_stmt(sql), Statement::CreateFunction(CreateFunction { or_alter: false, or_replace: false, temporary: false, name: ObjectName::from(vec![Ident::new("add")]), args: Some(vec![ OperateFunctionArg::unnamed(DataType::Integer(None)), OperateFunctionArg::unnamed(DataType::Integer(None)), ]), return_type: Some(FunctionReturnType::DataType(DataType::Integer(None))), language: Some("SQL".into()), behavior: Some(FunctionBehavior::Immutable), called_on_null: Some(FunctionCalledOnNull::Strict), parallel: Some(FunctionParallel::Safe), security: None, set_params: vec![], function_body: Some(CreateFunctionBody::AsBeforeOptions { body: Expr::Value( (Value::SingleQuotedString("select $1 + $2;".into())).with_empty_span() ), link_symbol: None, }), if_not_exists: false, using: None, determinism_specifier: None, options: None, remote_connection: None, }) ); } #[test] fn parse_create_function_detailed() { pg_and_generic().verified_stmt("CREATE OR REPLACE FUNCTION add(a INTEGER, IN b INTEGER = 1) RETURNS INTEGER LANGUAGE SQL IMMUTABLE PARALLEL RESTRICTED RETURN a + b"); pg_and_generic().verified_stmt("CREATE OR REPLACE FUNCTION add(a INTEGER, IN b INTEGER = 1) RETURNS INTEGER LANGUAGE SQL IMMUTABLE RETURNS NULL ON NULL INPUT PARALLEL RESTRICTED RETURN a + b"); pg_and_generic().verified_stmt("CREATE OR REPLACE FUNCTION add(a INTEGER, IN b INTEGER = 1) RETURNS INTEGER LANGUAGE SQL STABLE PARALLEL UNSAFE RETURN a + b"); pg_and_generic().verified_stmt("CREATE OR REPLACE FUNCTION add(a INTEGER, IN b INTEGER = 1) RETURNS INTEGER LANGUAGE SQL STABLE CALLED ON NULL INPUT PARALLEL UNSAFE RETURN a + b"); pg_and_generic().verified_stmt(r#"CREATE OR REPLACE FUNCTION increment(i INTEGER) RETURNS INTEGER LANGUAGE plpgsql AS $$ BEGIN RETURN i + 1; END; $$"#); pg_and_generic().verified_stmt(r#"CREATE OR REPLACE FUNCTION no_arg() RETURNS VOID LANGUAGE plpgsql AS $$ BEGIN DELETE FROM my_table; END; $$"#); pg_and_generic().verified_stmt(r#"CREATE OR REPLACE FUNCTION return_table(i INTEGER) RETURNS TABLE(id UUID, is_active BOOLEAN) LANGUAGE plpgsql AS $$ BEGIN RETURN QUERY SELECT NULL::UUID, NULL::BOOLEAN; END; $$"#); pg_and_generic().one_statement_parses_to( "CREATE FUNCTION add(INTEGER, INTEGER DEFAULT 1) RETURNS INTEGER AS 'select $1 + $2;'", "CREATE FUNCTION add(INTEGER, INTEGER = 1) RETURNS INTEGER AS 'select $1 + $2;'", ); } #[test] fn parse_create_function_returns_setof() { pg_and_generic().verified_stmt( "CREATE FUNCTION get_users() RETURNS SETOF TEXT LANGUAGE sql AS 'SELECT name FROM users'", ); pg_and_generic().verified_stmt( "CREATE FUNCTION get_ids() RETURNS SETOF INTEGER LANGUAGE sql AS 'SELECT id FROM users'", ); pg_and_generic().verified_stmt( r#"CREATE FUNCTION get_all() RETURNS SETOF my_schema."MyType" LANGUAGE sql AS 'SELECT * FROM t'"#, ); pg_and_generic().verified_stmt( "CREATE FUNCTION get_rows() RETURNS SETOF RECORD LANGUAGE sql AS 'SELECT * FROM t'", ); let sql = "CREATE FUNCTION get_names() RETURNS SETOF TEXT LANGUAGE sql AS 'SELECT name FROM t'"; match pg_and_generic().verified_stmt(sql) { Statement::CreateFunction(CreateFunction { return_type, .. }) => { assert_eq!(return_type, Some(FunctionReturnType::SetOf(DataType::Text))); } _ => panic!("Expected CreateFunction"), } } #[test] fn parse_create_function_with_security() { let sql = "CREATE FUNCTION test_fn() RETURNS void LANGUAGE sql SECURITY DEFINER AS $$ SELECT 1 $$"; match pg_and_generic().verified_stmt(sql) { Statement::CreateFunction(CreateFunction { security, .. }) => { assert_eq!(security, Some(FunctionSecurity::Definer)); } _ => panic!("Expected CreateFunction"), } let sql2 = "CREATE FUNCTION test_fn() RETURNS void LANGUAGE sql SECURITY INVOKER AS $$ SELECT 1 $$"; match pg_and_generic().verified_stmt(sql2) { Statement::CreateFunction(CreateFunction { security, .. }) => { assert_eq!(security, Some(FunctionSecurity::Invoker)); } _ => panic!("Expected CreateFunction"), } } #[test] fn parse_create_function_with_set_params() { let sql = "CREATE FUNCTION test_fn() RETURNS void LANGUAGE sql SET search_path = auth, pg_temp, public AS $$ SELECT 1 $$"; match pg_and_generic().verified_stmt(sql) { Statement::CreateFunction(CreateFunction { set_params, .. }) => { assert_eq!(set_params.len(), 1); assert_eq!(set_params[0].name.to_string(), "search_path"); } _ => panic!("Expected CreateFunction"), } // Test multiple SET params let sql2 = "CREATE FUNCTION test_fn() RETURNS void LANGUAGE sql SET search_path = public SET statement_timeout = '5s' AS $$ SELECT 1 $$"; match pg_and_generic().verified_stmt(sql2) { Statement::CreateFunction(CreateFunction { set_params, .. }) => { assert_eq!(set_params.len(), 2); } _ => panic!("Expected CreateFunction"), } // Test FROM CURRENT let sql3 = "CREATE FUNCTION test_fn() RETURNS void LANGUAGE sql SET search_path FROM CURRENT AS $$ SELECT 1 $$"; match pg_and_generic().verified_stmt(sql3) { Statement::CreateFunction(CreateFunction { set_params, .. }) => { assert_eq!(set_params.len(), 1); assert!(matches!(set_params[0].value, FunctionSetValue::FromCurrent)); } _ => panic!("Expected CreateFunction"), } } #[test] fn parse_incorrect_create_function_parallel() { let sql = "CREATE FUNCTION add(INTEGER, INTEGER) RETURNS INTEGER LANGUAGE SQL PARALLEL BLAH AS 'select $1 + $2;'"; assert!(pg().parse_sql_statements(sql).is_err()); } #[test] fn parse_create_function_c_with_module_pathname() { let sql = "CREATE FUNCTION cas_in(input cstring) RETURNS cas LANGUAGE c IMMUTABLE PARALLEL SAFE AS 'MODULE_PATHNAME', 'cas_in_wrapper'"; assert_eq!( pg_and_generic().verified_stmt(sql), Statement::CreateFunction(CreateFunction { or_alter: false, or_replace: false, temporary: false, name: ObjectName::from(vec![Ident::new("cas_in")]), args: Some(vec![OperateFunctionArg::with_name( "input", DataType::Custom(ObjectName::from(vec![Ident::new("cstring")]), vec![]), ),]), return_type: Some(FunctionReturnType::DataType(DataType::Custom( ObjectName::from(vec![Ident::new("cas")]), vec![] ))), language: Some("c".into()), behavior: Some(FunctionBehavior::Immutable), called_on_null: None, parallel: Some(FunctionParallel::Safe), security: None, set_params: vec![], function_body: Some(CreateFunctionBody::AsBeforeOptions { body: Expr::Value( (Value::SingleQuotedString("MODULE_PATHNAME".into())).with_empty_span() ), link_symbol: Some(Expr::Value( (Value::SingleQuotedString("cas_in_wrapper".into())).with_empty_span() )), }), if_not_exists: false, using: None, determinism_specifier: None, options: None, remote_connection: None, }) ); // Test that attribute order flexibility works (IMMUTABLE before LANGUAGE) let sql_alt_order = "CREATE FUNCTION cas_in(input cstring) RETURNS cas IMMUTABLE PARALLEL SAFE LANGUAGE c AS 'MODULE_PATHNAME', 'cas_in_wrapper'"; pg_and_generic().one_statement_parses_to( sql_alt_order, "CREATE FUNCTION cas_in(input cstring) RETURNS cas LANGUAGE c IMMUTABLE PARALLEL SAFE AS 'MODULE_PATHNAME', 'cas_in_wrapper'" ); } #[test] fn parse_drop_function() { let sql = "DROP FUNCTION IF EXISTS test_func"; assert_eq!( pg().verified_stmt(sql), Statement::DropFunction(DropFunction { if_exists: true, func_desc: vec![FunctionDesc { name: ObjectName::from(vec![Ident { value: "test_func".to_string(), quote_style: None, span: Span::empty(), }]), args: None }], drop_behavior: None }) ); let sql = "DROP FUNCTION IF EXISTS test_func(a INTEGER, IN b INTEGER = 1)"; assert_eq!( pg().verified_stmt(sql), Statement::DropFunction(DropFunction { if_exists: true, func_desc: vec![FunctionDesc { name: ObjectName::from(vec![Ident { value: "test_func".to_string(), quote_style: None, span: Span::empty(), }]), args: Some(vec![ OperateFunctionArg::with_name("a", DataType::Integer(None)), OperateFunctionArg { mode: Some(ArgMode::In), name: Some("b".into()), data_type: DataType::Integer(None), default_expr: Some(Expr::Value( (Value::Number("1".parse().unwrap(), false)).with_empty_span() )), } ]), }], drop_behavior: None }) ); let sql = "DROP FUNCTION IF EXISTS test_func1(a INTEGER, IN b INTEGER = 1), test_func2(a VARCHAR, IN b INTEGER = 1)"; assert_eq!( pg().verified_stmt(sql), Statement::DropFunction(DropFunction { if_exists: true, func_desc: vec![ FunctionDesc { name: ObjectName::from(vec![Ident { value: "test_func1".to_string(), quote_style: None, span: Span::empty(), }]), args: Some(vec![ OperateFunctionArg::with_name("a", DataType::Integer(None)), OperateFunctionArg { mode: Some(ArgMode::In), name: Some("b".into()), data_type: DataType::Integer(None), default_expr: Some(Expr::Value( (Value::Number("1".parse().unwrap(), false)).with_empty_span() )), } ]), }, FunctionDesc { name: ObjectName::from(vec![Ident { value: "test_func2".to_string(), quote_style: None, span: Span::empty(), }]), args: Some(vec![ OperateFunctionArg::with_name("a", DataType::Varchar(None)), OperateFunctionArg { mode: Some(ArgMode::In), name: Some("b".into()), data_type: DataType::Integer(None), default_expr: Some(Expr::Value( (Value::Number("1".parse().unwrap(), false)).with_empty_span() )), } ]), } ], drop_behavior: None }) ); } #[test] fn parse_drop_domain() { let sql = "DROP DOMAIN IF EXISTS jpeg_domain"; assert_eq!( pg().verified_stmt(sql), Statement::DropDomain(DropDomain { if_exists: true, name: ObjectName::from(vec![Ident { value: "jpeg_domain".to_string(), quote_style: None, span: Span::empty(), }]), drop_behavior: None }) ); let sql = "DROP DOMAIN jpeg_domain"; assert_eq!( pg().verified_stmt(sql), Statement::DropDomain(DropDomain { if_exists: false, name: ObjectName::from(vec![Ident { value: "jpeg_domain".to_string(), quote_style: None, span: Span::empty(), }]), drop_behavior: None }) ); let sql = "DROP DOMAIN IF EXISTS jpeg_domain CASCADE"; assert_eq!( pg().verified_stmt(sql), Statement::DropDomain(DropDomain { if_exists: true, name: ObjectName::from(vec![Ident { value: "jpeg_domain".to_string(), quote_style: None, span: Span::empty(), }]), drop_behavior: Some(DropBehavior::Cascade) }) ); let sql = "DROP DOMAIN IF EXISTS jpeg_domain RESTRICT"; assert_eq!( pg().verified_stmt(sql), Statement::DropDomain(DropDomain { if_exists: true, name: ObjectName::from(vec![Ident { value: "jpeg_domain".to_string(), quote_style: None, span: Span::empty(), }]), drop_behavior: Some(DropBehavior::Restrict) }) ); } #[test] fn parse_drop_procedure() { let sql = "DROP PROCEDURE IF EXISTS test_proc"; assert_eq!( pg().verified_stmt(sql), Statement::DropProcedure { if_exists: true, proc_desc: vec![FunctionDesc { name: ObjectName::from(vec![Ident { value: "test_proc".to_string(), quote_style: None, span: Span::empty(), }]), args: None }], drop_behavior: None } ); let sql = "DROP PROCEDURE IF EXISTS test_proc(a INTEGER, IN b INTEGER = 1)"; assert_eq!( pg().verified_stmt(sql), Statement::DropProcedure { if_exists: true, proc_desc: vec![FunctionDesc { name: ObjectName::from(vec![Ident { value: "test_proc".to_string(), quote_style: None, span: Span::empty(), }]), args: Some(vec![ OperateFunctionArg::with_name("a", DataType::Integer(None)), OperateFunctionArg { mode: Some(ArgMode::In), name: Some("b".into()), data_type: DataType::Integer(None), default_expr: Some(Expr::Value( (Value::Number("1".parse().unwrap(), false)).with_empty_span() )), } ]), }], drop_behavior: None } ); let sql = "DROP PROCEDURE IF EXISTS test_proc1(a INTEGER, IN b INTEGER = 1), test_proc2(a VARCHAR, IN b INTEGER = 1)"; assert_eq!( pg().verified_stmt(sql), Statement::DropProcedure { if_exists: true, proc_desc: vec![ FunctionDesc { name: ObjectName::from(vec![Ident { value: "test_proc1".to_string(), quote_style: None, span: Span::empty(), }]), args: Some(vec![ OperateFunctionArg::with_name("a", DataType::Integer(None)), OperateFunctionArg { mode: Some(ArgMode::In), name: Some("b".into()), data_type: DataType::Integer(None), default_expr: Some(Expr::Value( (Value::Number("1".parse().unwrap(), false)).with_empty_span() )), } ]), }, FunctionDesc { name: ObjectName::from(vec![Ident { value: "test_proc2".to_string(), quote_style: None, span: Span::empty(), }]), args: Some(vec![ OperateFunctionArg::with_name("a", DataType::Varchar(None)), OperateFunctionArg { mode: Some(ArgMode::In), name: Some("b".into()), data_type: DataType::Integer(None), default_expr: Some(Expr::Value( (Value::Number("1".parse().unwrap(), false)).with_empty_span() )), } ]), } ], drop_behavior: None } ); let res = pg().parse_sql_statements("DROP PROCEDURE testproc DROP"); assert_eq!( ParserError::ParserError("Expected: end of statement, found: DROP".to_string()), res.unwrap_err() ); let res = pg().parse_sql_statements("DROP PROCEDURE testproc SET NULL"); assert_eq!( ParserError::ParserError("Expected: end of statement, found: SET".to_string()), res.unwrap_err() ); } #[test] fn parse_dollar_quoted_string() { let sql = "SELECT $$hello$$, $tag_name$world$tag_name$, $$Foo$Bar$$, $$Foo$Bar$$col_name, $$$$, $tag_name$$tag_name$"; let stmt = pg().parse_sql_statements(sql).unwrap(); let projection = match stmt.first().unwrap() { Statement::Query(query) => match &*query.body { SetExpr::Select(select) => &select.projection, _ => unreachable!(), }, _ => unreachable!(), }; assert_eq!( &Expr::Value( (Value::DollarQuotedString(DollarQuotedString { tag: None, value: "hello".into() })) .with_empty_span() ), expr_from_projection(&projection[0]) ); assert_eq!( &Expr::Value( (Value::DollarQuotedString(DollarQuotedString { tag: Some("tag_name".into()), value: "world".into() })) .with_empty_span() ), expr_from_projection(&projection[1]) ); assert_eq!( &Expr::Value( (Value::DollarQuotedString(DollarQuotedString { tag: None, value: "Foo$Bar".into() })) .with_empty_span() ), expr_from_projection(&projection[2]) ); assert_eq!( projection[3], SelectItem::ExprWithAlias { expr: Expr::Value( (Value::DollarQuotedString(DollarQuotedString { tag: None, value: "Foo$Bar".into(), })) .with_empty_span() ), alias: Ident { value: "col_name".into(), quote_style: None, span: Span::empty(), }, }, ); assert_eq!( expr_from_projection(&projection[4]), &Expr::Value( (Value::DollarQuotedString(DollarQuotedString { tag: None, value: "".into() })) .with_empty_span() ), ); assert_eq!( expr_from_projection(&projection[5]), &Expr::Value( (Value::DollarQuotedString(DollarQuotedString { tag: Some("tag_name".into()), value: "".into() })) .with_empty_span() ), ); } #[test] fn parse_incorrect_dollar_quoted_string() { let sql = "SELECT $x$hello$$"; assert!(pg().parse_sql_statements(sql).is_err()); let sql = "SELECT $hello$$"; assert!(pg().parse_sql_statements(sql).is_err()); let sql = "SELECT $$$"; assert!(pg().parse_sql_statements(sql).is_err()); } #[test] fn parse_select_group_by_grouping_sets() { let select = pg_and_generic().verified_only_select( "SELECT brand, size, sum(sales) FROM items_sold GROUP BY size, GROUPING SETS ((brand), (size), ())" ); assert_eq!( GroupByExpr::Expressions( vec![ Expr::Identifier(Ident::new("size")), Expr::GroupingSets(vec![ vec![Expr::Identifier(Ident::new("brand"))], vec![Expr::Identifier(Ident::new("size"))], vec![], ]), ], vec![] ), select.group_by ); } #[test] fn parse_select_group_by_rollup() { let select = pg_and_generic().verified_only_select( "SELECT brand, size, sum(sales) FROM items_sold GROUP BY size, ROLLUP (brand, size)", ); assert_eq!( GroupByExpr::Expressions( vec![ Expr::Identifier(Ident::new("size")), Expr::Rollup(vec![ vec![Expr::Identifier(Ident::new("brand"))], vec![Expr::Identifier(Ident::new("size"))], ]), ], vec![] ), select.group_by ); } #[test] fn parse_select_group_by_cube() { let select = pg_and_generic().verified_only_select( "SELECT brand, size, sum(sales) FROM items_sold GROUP BY size, CUBE (brand, size)", ); assert_eq!( GroupByExpr::Expressions( vec![ Expr::Identifier(Ident::new("size")), Expr::Cube(vec![ vec![Expr::Identifier(Ident::new("brand"))], vec![Expr::Identifier(Ident::new("size"))], ]), ], vec![] ), select.group_by ); } #[test] fn parse_truncate() { let truncate = pg_and_generic().verified_stmt("TRUNCATE db.table_name"); let table_name = ObjectName::from(vec![Ident::new("db"), Ident::new("table_name")]); let table_names = vec![TruncateTableTarget { name: table_name.clone(), only: false, has_asterisk: false, }]; assert_eq!( Statement::Truncate(Truncate { table_names, partitions: None, table: false, if_exists: false, identity: None, cascade: None, on_cluster: None, }), truncate ); } #[test] fn parse_truncate_with_options() { let truncate = pg_and_generic() .verified_stmt("TRUNCATE TABLE ONLY db.table_name RESTART IDENTITY CASCADE"); let table_name = ObjectName::from(vec![Ident::new("db"), Ident::new("table_name")]); let table_names = vec![TruncateTableTarget { name: table_name.clone(), only: true, has_asterisk: false, }]; assert_eq!( Statement::Truncate(Truncate { table_names, partitions: None, table: true, if_exists: false, identity: Some(TruncateIdentityOption::Restart), cascade: Some(CascadeOption::Cascade), on_cluster: None, }), truncate ); } #[test] fn parse_truncate_with_table_list() { let truncate = pg().verified_stmt( "TRUNCATE TABLE db.table_name, db.other_table_name RESTART IDENTITY CASCADE", ); let table_name_a = ObjectName::from(vec![Ident::new("db"), Ident::new("table_name")]); let table_name_b = ObjectName::from(vec![Ident::new("db"), Ident::new("other_table_name")]); let table_names = vec![ TruncateTableTarget { name: table_name_a.clone(), only: false, has_asterisk: false, }, TruncateTableTarget { name: table_name_b.clone(), only: false, has_asterisk: false, }, ]; assert_eq!( Statement::Truncate(Truncate { table_names, partitions: None, table: true, if_exists: false, identity: Some(TruncateIdentityOption::Restart), cascade: Some(CascadeOption::Cascade), on_cluster: None, }), truncate ); } #[test] fn parse_truncate_with_descendant() { let truncate = pg_and_generic().verified_stmt("TRUNCATE TABLE t *"); let table_names = vec![TruncateTableTarget { name: ObjectName::from(vec![Ident::new("t")]), only: false, has_asterisk: true, }]; assert_eq!( Statement::Truncate(Truncate { table_names, partitions: None, table: true, if_exists: false, identity: None, cascade: None, on_cluster: None, }), truncate ); let truncate = pg_and_generic() .verified_stmt("TRUNCATE TABLE ONLY parent, child *, grandchild RESTART IDENTITY"); let table_names = vec![ TruncateTableTarget { name: ObjectName::from(vec![Ident::new("parent")]), only: true, has_asterisk: false, }, TruncateTableTarget { name: ObjectName::from(vec![Ident::new("child")]), only: false, has_asterisk: true, }, TruncateTableTarget { name: ObjectName::from(vec![Ident::new("grandchild")]), only: false, has_asterisk: false, }, ]; assert_eq!( Statement::Truncate(Truncate { table_names, partitions: None, table: true, if_exists: false, identity: Some(TruncateIdentityOption::Restart), cascade: None, on_cluster: None, }), truncate ); } #[test] fn parse_select_regexp_as_column_name() { pg_and_generic().verified_only_select( "SELECT REGEXP.REGEXP AS REGEXP FROM REGEXP AS REGEXP WHERE REGEXP.REGEXP", ); } #[test] fn parse_create_table_with_alias() { let sql = "CREATE TABLE public.datatype_aliases ( int8_col INT8, int4_col INT4, int2_col INT2, float8_col FLOAT8, float4_col FLOAT4, bool_col BOOL );"; match pg_and_generic().one_statement_parses_to(sql, "") { Statement::CreateTable(CreateTable { name, columns, constraints, if_not_exists: false, external: false, file_format: None, location: None, .. }) => { assert_eq!("public.datatype_aliases", name.to_string()); assert_eq!( columns, vec![ ColumnDef { name: "int8_col".into(), data_type: DataType::Int8(None), options: vec![] }, ColumnDef { name: "int4_col".into(), data_type: DataType::Int4(None), options: vec![] }, ColumnDef { name: "int2_col".into(), data_type: DataType::Int2(None), options: vec![] }, ColumnDef { name: "float8_col".into(), data_type: DataType::Float8, options: vec![] }, ColumnDef { name: "float4_col".into(), data_type: DataType::Float4, options: vec![] }, ColumnDef { name: "bool_col".into(), data_type: DataType::Bool, options: vec![] }, ] ); assert!(constraints.is_empty()); } _ => unreachable!(), } } #[test] fn parse_create_table_with_partition_by() { let sql = "CREATE TABLE t1 (a INT, b TEXT) PARTITION BY RANGE(a)"; match pg_and_generic().verified_stmt(sql) { Statement::CreateTable(create_table) => { assert_eq!("t1", create_table.name.to_string()); assert_eq!( vec![ ColumnDef { name: "a".into(), data_type: DataType::Int(None), options: vec![] }, ColumnDef { name: "b".into(), data_type: DataType::Text, options: vec![] } ], create_table.columns ); match *create_table.partition_by.unwrap() { Expr::Function(f) => { assert_eq!("RANGE", f.name.to_string()); assert_eq!( FunctionArguments::List(FunctionArgumentList { duplicate_treatment: None, clauses: vec![], args: vec![FunctionArg::Unnamed(FunctionArgExpr::Expr( Expr::Identifier(Ident::new("a")) ))], }), f.args ); } _ => unreachable!(), } } _ => unreachable!(), } } #[test] fn parse_join_constraint_unnest_alias() { assert_eq!( only( pg().verified_only_select("SELECT * FROM t1 JOIN UNNEST(t1.a) AS f ON c1 = c2") .from ) .joins, vec![Join { relation: TableFactor::UNNEST { alias: table_alias(true, "f"), array_exprs: vec![Expr::CompoundIdentifier(vec![ Ident::new("t1"), Ident::new("a") ])], with_offset: false, with_offset_alias: None, with_ordinality: false, }, global: false, join_operator: JoinOperator::Join(JoinConstraint::On(Expr::BinaryOp { left: Box::new(Expr::Identifier("c1".into())), op: BinaryOperator::Eq, right: Box::new(Expr::Identifier("c2".into())), })), }] ); } #[test] fn test_complex_postgres_insert_with_alias() { let sql1 = "WITH existing AS (SELECT test_table.id FROM test_tables AS test_table WHERE (a = 12) AND (b = 34)), inserted AS (INSERT INTO test_tables AS test_table (id, a, b, c) VALUES (DEFAULT, 56, 78, 90) ON CONFLICT(a, b) DO UPDATE SET c = EXCLUDED.c WHERE (test_table.c <> EXCLUDED.c)) SELECT c FROM existing"; pg().verified_stmt(sql1); } #[cfg(not(feature = "bigdecimal"))] #[test] fn test_simple_postgres_insert_with_alias() { let sql2 = "INSERT INTO test_tables AS test_table (id, a) VALUES (DEFAULT, 123)"; let statement = pg().verified_stmt(sql2); assert_eq!( statement, Statement::Insert(Insert { insert_token: AttachedToken::empty(), optimizer_hints: vec![], or: None, ignore: false, into: true, table: TableObject::TableName(ObjectName::from(vec![Ident { value: "test_tables".to_string(), quote_style: None, span: Span::empty(), }])), table_alias: Some(TableAliasWithoutColumns { explicit: true, alias: Ident { value: "test_table".to_string(), quote_style: None, span: Span::empty(), } }), columns: vec![ ObjectName::from(Ident { value: "id".to_string(), quote_style: None, span: Span::empty(), }), ObjectName::from(Ident { value: "a".to_string(), quote_style: None, span: Span::empty(), }) ], overwrite: false, source: Some(Box::new(Query { with: None, body: Box::new(SetExpr::Values(Values { value_keyword: false, explicit_row: false, rows: vec![Parens::with_empty_span(vec![ Expr::Identifier(Ident::new("DEFAULT")), Expr::Value((Value::Number("123".to_string(), false)).with_empty_span()) ])] })), order_by: None, limit_clause: None, fetch: None, locks: vec![], for_clause: None, settings: None, format_clause: None, pipe_operators: vec![], })), assignments: vec![], partitioned: None, after_columns: vec![], has_table_keyword: false, on: None, returning: None, output: None, replace_into: false, priority: None, insert_alias: None, settings: None, format_clause: None, multi_table_insert_type: None, multi_table_into_clauses: vec![], multi_table_when_clauses: vec![], multi_table_else_clause: None, }) ) } #[cfg(feature = "bigdecimal")] #[test] fn test_simple_postgres_insert_with_alias() { let sql2 = "INSERT INTO test_tables AS test_table (id, a) VALUES (DEFAULT, 123)"; let statement = pg().verified_stmt(sql2); assert_eq!( statement, Statement::Insert(Insert { insert_token: AttachedToken::empty(), optimizer_hints: vec![], or: None, ignore: false, into: true, table: TableObject::TableName(ObjectName::from(vec![Ident { value: "test_tables".to_string(), quote_style: None, span: Span::empty(), }])), table_alias: Some(TableAliasWithoutColumns { explicit: true, alias: Ident { value: "test_table".to_string(), quote_style: None, span: Span::empty(), } }), columns: vec![ ObjectName::from(Ident { value: "id".to_string(), quote_style: None, span: Span::empty(), }), ObjectName::from(Ident { value: "a".to_string(), quote_style: None, span: Span::empty(), }) ], overwrite: false, source: Some(Box::new(Query { with: None, body: Box::new(SetExpr::Values(Values { value_keyword: false, explicit_row: false, rows: vec![Parens::with_empty_span(vec![ Expr::Identifier(Ident::new("DEFAULT")), Expr::Value( (Value::Number(bigdecimal::BigDecimal::new(123.into(), 0), false)) .with_empty_span() ) ])] })), order_by: None, limit_clause: None, fetch: None, locks: vec![], for_clause: None, settings: None, format_clause: None, pipe_operators: vec![], })), assignments: vec![], partitioned: None, after_columns: vec![], has_table_keyword: false, on: None, returning: None, output: None, replace_into: false, priority: None, insert_alias: None, settings: None, format_clause: None, multi_table_insert_type: None, multi_table_into_clauses: vec![], multi_table_when_clauses: vec![], multi_table_else_clause: None, }) ) } #[test] fn test_simple_insert_with_quoted_alias() { let sql = r#"INSERT INTO test_tables AS "Test_Table" (id, a) VALUES (DEFAULT, '0123')"#; let statement = pg().verified_stmt(sql); assert_eq!( statement, Statement::Insert(Insert { insert_token: AttachedToken::empty(), optimizer_hints: vec![], or: None, ignore: false, into: true, table: TableObject::TableName(ObjectName::from(vec![Ident { value: "test_tables".to_string(), quote_style: None, span: Span::empty(), }])), table_alias: Some(TableAliasWithoutColumns { explicit: true, alias: Ident { value: "Test_Table".to_string(), quote_style: Some('"'), span: Span::empty(), } }), columns: vec![ ObjectName::from(Ident { value: "id".to_string(), quote_style: None, span: Span::empty(), }), ObjectName::from(Ident { value: "a".to_string(), quote_style: None, span: Span::empty(), }) ], overwrite: false, source: Some(Box::new(Query { with: None, body: Box::new(SetExpr::Values(Values { value_keyword: false, explicit_row: false, rows: vec![Parens::with_empty_span(vec![ Expr::Identifier(Ident::new("DEFAULT")), Expr::Value( (Value::SingleQuotedString("0123".to_string())).with_empty_span() ) ])] })), order_by: None, limit_clause: None, fetch: None, locks: vec![], for_clause: None, settings: None, format_clause: None, pipe_operators: vec![], })), assignments: vec![], partitioned: None, after_columns: vec![], has_table_keyword: false, on: None, returning: None, output: None, replace_into: false, priority: None, insert_alias: None, settings: None, format_clause: None, multi_table_insert_type: None, multi_table_into_clauses: vec![], multi_table_when_clauses: vec![], multi_table_else_clause: None, }) ) } #[test] fn parse_array_agg() { // follows general function with wildcard code path let sql = r#"SELECT GREATEST(sections_tbl.*) AS sections FROM sections_tbl"#; pg().verified_stmt(sql); // follows special-case array_agg code path let sql2 = "SELECT ARRAY_AGG(sections_tbl.*) AS sections FROM sections_tbl"; pg().verified_stmt(sql2); // handles multi-part identifier with general code path let sql3 = "SELECT GREATEST(my_schema.sections_tbl.*) AS sections FROM sections_tbl"; pg().verified_stmt(sql3); // handles multi-part identifier with array_agg code path let sql4 = "SELECT ARRAY_AGG(my_schema.sections_tbl.*) AS sections FROM sections_tbl"; pg().verified_stmt(sql4); } #[test] fn parse_mat_cte() { let sql = r#"WITH cte AS MATERIALIZED (SELECT id FROM accounts) SELECT id FROM cte"#; pg().verified_stmt(sql); let sql2 = r#"WITH cte AS NOT MATERIALIZED (SELECT id FROM accounts) SELECT id FROM cte"#; pg().verified_stmt(sql2); } #[test] fn parse_at_time_zone() { pg_and_generic().verified_expr("CURRENT_TIMESTAMP AT TIME ZONE tz"); pg_and_generic().verified_expr("CURRENT_TIMESTAMP AT TIME ZONE ('America/' || 'Los_Angeles')"); // check precedence let expr = Expr::BinaryOp { left: Box::new(Expr::AtTimeZone { timestamp: Box::new(Expr::TypedString(TypedString { data_type: DataType::Timestamp(None, TimezoneInfo::None), value: ValueWithSpan { value: Value::SingleQuotedString("2001-09-28 01:00".to_string()), span: Span::empty(), }, uses_odbc_syntax: false, })), time_zone: Box::new(Expr::Cast { kind: CastKind::DoubleColon, expr: Box::new(Expr::Value( Value::SingleQuotedString("America/Los_Angeles".to_owned()).with_empty_span(), )), data_type: DataType::Text, array: false, format: None, }), }), op: BinaryOperator::Plus, right: Box::new(Expr::Interval(Interval { value: Box::new(Expr::Value( Value::SingleQuotedString("23 hours".to_owned()).with_empty_span(), )), leading_field: None, leading_precision: None, last_field: None, fractional_seconds_precision: None, })), }; pretty_assertions::assert_eq!( pg_and_generic().verified_expr( "TIMESTAMP '2001-09-28 01:00' AT TIME ZONE 'America/Los_Angeles'::TEXT + INTERVAL '23 hours'", ), expr ); } #[test] fn parse_interval_data_type() { pg_and_generic().verified_stmt("CREATE TABLE t (i INTERVAL)"); for p in 0..=6 { pg_and_generic().verified_stmt(&format!("CREATE TABLE t (i INTERVAL({p}))")); pg_and_generic().verified_stmt(&format!("SELECT '1 second'::INTERVAL({p})")); pg_and_generic().verified_stmt(&format!("SELECT CAST('1 second' AS INTERVAL({p}))")); } let fields = [ "YEAR", "MONTH", "DAY", "HOUR", "MINUTE", "SECOND", "YEAR TO MONTH", "DAY TO HOUR", "DAY TO MINUTE", "DAY TO SECOND", "HOUR TO MINUTE", "HOUR TO SECOND", "MINUTE TO SECOND", ]; for field in fields { pg_and_generic().verified_stmt(&format!("CREATE TABLE t (i INTERVAL {field})")); pg_and_generic().verified_stmt(&format!("SELECT '1 second'::INTERVAL {field}")); pg_and_generic().verified_stmt(&format!("SELECT CAST('1 second' AS INTERVAL {field})")); } for p in 0..=6 { for field in fields { pg_and_generic().verified_stmt(&format!("CREATE TABLE t (i INTERVAL {field}({p}))")); pg_and_generic().verified_stmt(&format!("SELECT '1 second'::INTERVAL {field}({p})")); pg_and_generic() .verified_stmt(&format!("SELECT CAST('1 second' AS INTERVAL {field}({p}))")); } } } #[test] fn parse_interval_keyword_as_unquoted_identifier() { pg().verified_stmt("SELECT MAX(interval) FROM tbl"); pg().verified_expr("INTERVAL '1 day'"); } #[test] fn parse_create_table_with_options() { let sql = "CREATE TABLE t (c INT) WITH (foo = 'bar', a = 123)"; match pg().verified_stmt(sql) { Statement::CreateTable(CreateTable { table_options, .. }) => { let with_options = match table_options { CreateTableOptions::With(options) => options, _ => unreachable!(), }; assert_eq!( vec![ SqlOption::KeyValue { key: "foo".into(), value: Expr::Value( (Value::SingleQuotedString("bar".into())).with_empty_span() ), }, SqlOption::KeyValue { key: "a".into(), value: Expr::value(number("123")), }, ], with_options ); } _ => unreachable!(), } } #[test] fn test_table_function_with_ordinality() { let from = pg_and_generic() .verified_only_select("SELECT * FROM generate_series(1, 10) WITH ORDINALITY AS t") .from; assert_eq!(1, from.len()); match from[0].relation { TableFactor::Table { ref name, with_ordinality: true, .. } => { assert_eq!("generate_series", name.to_string().as_str()); } _ => panic!("Expecting TableFactor::Table with ordinality"), } } #[test] fn test_lateral_function_with_ordinality_and_column_aliases() { let from = pg() .verified_only_select( "SELECT * FROM tbl, \ LATERAL json_array_elements(c1::JSON) \ WITH ORDINALITY AS t (c1, index)", ) .from; assert_eq!(2, from.len()); match &from[1].relation { TableFactor::Function { lateral: true, name, with_ordinality: true, alias: Some(alias), .. } => { assert_eq!("json_array_elements", name.to_string().as_str()); assert_eq!("t", alias.name.value.as_str()); assert_eq!(2, alias.columns.len()); assert_eq!("c1", alias.columns[0].name.value.as_str()); assert_eq!("index", alias.columns[1].name.value.as_str()); } _ => panic!("Expecting TableFactor::Function with ordinality and alias columns"), } } #[test] fn test_table_unnest_with_ordinality() { let from = pg_and_generic() .verified_only_select("SELECT * FROM UNNEST([10, 20, 30]) WITH ORDINALITY AS t") .from; assert_eq!(1, from.len()); match from[0].relation { TableFactor::UNNEST { with_ordinality: true, .. } => {} _ => panic!("Expecting TableFactor::UNNEST with ordinality"), } } #[test] fn test_escaped_string_literal() { match pg().verified_expr(r#"E'\n'"#) { Expr::Value(ValueWithSpan { value: Value::EscapedStringLiteral(s), span: _, }) => { assert_eq!("\n", s); } _ => unreachable!(), } } #[test] fn parse_create_domain() { let sql1 = "CREATE DOMAIN my_domain AS INTEGER CHECK (VALUE > 0)"; let expected = Statement::CreateDomain(CreateDomain { name: ObjectName::from(vec![Ident::new("my_domain")]), data_type: DataType::Integer(None), collation: None, default: None, constraints: vec![CheckConstraint { name: None, expr: Box::new(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("VALUE"))), op: BinaryOperator::Gt, right: Box::new(Expr::Value(test_utils::number("0").into())), }), enforced: None, } .into()], }); assert_eq!(pg().verified_stmt(sql1), expected); let sql2 = "CREATE DOMAIN my_domain AS INTEGER COLLATE \"en_US\" CHECK (VALUE > 0)"; let expected = Statement::CreateDomain(CreateDomain { name: ObjectName::from(vec![Ident::new("my_domain")]), data_type: DataType::Integer(None), collation: Some(Ident::with_quote('"', "en_US")), default: None, constraints: vec![CheckConstraint { name: None, expr: Box::new(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("VALUE"))), op: BinaryOperator::Gt, right: Box::new(Expr::Value(test_utils::number("0").into())), }), enforced: None, } .into()], }); assert_eq!(pg().verified_stmt(sql2), expected); let sql3 = "CREATE DOMAIN my_domain AS INTEGER DEFAULT 1 CHECK (VALUE > 0)"; let expected = Statement::CreateDomain(CreateDomain { name: ObjectName::from(vec![Ident::new("my_domain")]), data_type: DataType::Integer(None), collation: None, default: Some(Expr::Value(test_utils::number("1").into())), constraints: vec![CheckConstraint { name: None, expr: Box::new(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("VALUE"))), op: BinaryOperator::Gt, right: Box::new(Expr::Value(test_utils::number("0").into())), }), enforced: None, } .into()], }); assert_eq!(pg().verified_stmt(sql3), expected); let sql4 = "CREATE DOMAIN my_domain AS INTEGER COLLATE \"en_US\" DEFAULT 1 CHECK (VALUE > 0)"; let expected = Statement::CreateDomain(CreateDomain { name: ObjectName::from(vec![Ident::new("my_domain")]), data_type: DataType::Integer(None), collation: Some(Ident::with_quote('"', "en_US")), default: Some(Expr::Value(test_utils::number("1").into())), constraints: vec![CheckConstraint { name: None, expr: Box::new(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("VALUE"))), op: BinaryOperator::Gt, right: Box::new(Expr::Value(test_utils::number("0").into())), }), enforced: None, } .into()], }); assert_eq!(pg().verified_stmt(sql4), expected); let sql5 = "CREATE DOMAIN my_domain AS INTEGER CONSTRAINT my_constraint CHECK (VALUE > 0)"; let expected = Statement::CreateDomain(CreateDomain { name: ObjectName::from(vec![Ident::new("my_domain")]), data_type: DataType::Integer(None), collation: None, default: None, constraints: vec![CheckConstraint { name: Some(Ident::new("my_constraint")), expr: Box::new(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("VALUE"))), op: BinaryOperator::Gt, right: Box::new(Expr::Value(test_utils::number("0").into())), }), enforced: None, } .into()], }); assert_eq!(pg().verified_stmt(sql5), expected); } #[test] fn parse_create_simple_before_insert_trigger() { let sql = "CREATE TRIGGER check_insert BEFORE INSERT ON accounts FOR EACH ROW EXECUTE FUNCTION check_account_insert"; let expected = Statement::CreateTrigger(CreateTrigger { or_alter: false, temporary: false, or_replace: false, is_constraint: false, name: ObjectName::from(vec![Ident::new("check_insert")]), period: Some(TriggerPeriod::Before), period_before_table: true, events: vec![TriggerEvent::Insert], table_name: ObjectName::from(vec![Ident::new("accounts")]), referenced_table_name: None, referencing: vec![], trigger_object: Some(TriggerObjectKind::ForEach(TriggerObject::Row)), condition: None, exec_body: Some(TriggerExecBody { exec_type: TriggerExecBodyType::Function, func_desc: FunctionDesc { name: ObjectName::from(vec![Ident::new("check_account_insert")]), args: None, }, }), statements_as: false, statements: None, characteristics: None, }); assert_eq!(pg().verified_stmt(sql), expected); } #[test] fn parse_create_after_update_trigger_with_condition() { let sql = "CREATE TRIGGER check_update AFTER UPDATE ON accounts FOR EACH ROW WHEN (NEW.balance > 10000) EXECUTE FUNCTION check_account_update"; let expected = Statement::CreateTrigger(CreateTrigger { or_alter: false, temporary: false, or_replace: false, is_constraint: false, name: ObjectName::from(vec![Ident::new("check_update")]), period: Some(TriggerPeriod::After), period_before_table: true, events: vec![TriggerEvent::Update(vec![])], table_name: ObjectName::from(vec![Ident::new("accounts")]), referenced_table_name: None, referencing: vec![], trigger_object: Some(TriggerObjectKind::ForEach(TriggerObject::Row)), condition: Some(Expr::Nested(Box::new(Expr::BinaryOp { left: Box::new(Expr::CompoundIdentifier(vec![ Ident::new("NEW"), Ident::new("balance"), ])), op: BinaryOperator::Gt, right: Box::new(Expr::value(number("10000"))), }))), exec_body: Some(TriggerExecBody { exec_type: TriggerExecBodyType::Function, func_desc: FunctionDesc { name: ObjectName::from(vec![Ident::new("check_account_update")]), args: None, }, }), statements_as: false, statements: None, characteristics: None, }); assert_eq!(pg().verified_stmt(sql), expected); } #[test] fn parse_create_instead_of_delete_trigger() { let sql = "CREATE TRIGGER check_delete INSTEAD OF DELETE ON accounts FOR EACH ROW EXECUTE FUNCTION check_account_deletes"; let expected = Statement::CreateTrigger(CreateTrigger { or_alter: false, temporary: false, or_replace: false, is_constraint: false, name: ObjectName::from(vec![Ident::new("check_delete")]), period: Some(TriggerPeriod::InsteadOf), period_before_table: true, events: vec![TriggerEvent::Delete], table_name: ObjectName::from(vec![Ident::new("accounts")]), referenced_table_name: None, referencing: vec![], trigger_object: Some(TriggerObjectKind::ForEach(TriggerObject::Row)), condition: None, exec_body: Some(TriggerExecBody { exec_type: TriggerExecBodyType::Function, func_desc: FunctionDesc { name: ObjectName::from(vec![Ident::new("check_account_deletes")]), args: None, }, }), statements_as: false, statements: None, characteristics: None, }); assert_eq!(pg().verified_stmt(sql), expected); } #[test] fn parse_create_trigger_with_multiple_events_and_deferrable() { let sql = "CREATE CONSTRAINT TRIGGER check_multiple_events BEFORE INSERT OR UPDATE OR DELETE ON accounts DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION check_account_changes"; let expected = Statement::CreateTrigger(CreateTrigger { or_alter: false, temporary: false, or_replace: false, is_constraint: true, name: ObjectName::from(vec![Ident::new("check_multiple_events")]), period: Some(TriggerPeriod::Before), period_before_table: true, events: vec![ TriggerEvent::Insert, TriggerEvent::Update(vec![]), TriggerEvent::Delete, ], table_name: ObjectName::from(vec![Ident::new("accounts")]), referenced_table_name: None, referencing: vec![], trigger_object: Some(TriggerObjectKind::ForEach(TriggerObject::Row)), condition: None, exec_body: Some(TriggerExecBody { exec_type: TriggerExecBodyType::Function, func_desc: FunctionDesc { name: ObjectName::from(vec![Ident::new("check_account_changes")]), args: None, }, }), statements_as: false, statements: None, characteristics: Some(ConstraintCharacteristics { deferrable: Some(true), initially: Some(DeferrableInitial::Deferred), enforced: None, }), }); assert_eq!(pg().verified_stmt(sql), expected); } #[test] fn parse_create_trigger_with_referencing() { let sql = "CREATE TRIGGER check_referencing BEFORE INSERT ON accounts REFERENCING NEW TABLE AS new_accounts OLD TABLE AS old_accounts FOR EACH ROW EXECUTE FUNCTION check_account_referencing"; let expected = Statement::CreateTrigger(CreateTrigger { or_alter: false, temporary: false, or_replace: false, is_constraint: false, name: ObjectName::from(vec![Ident::new("check_referencing")]), period: Some(TriggerPeriod::Before), period_before_table: true, events: vec![TriggerEvent::Insert], table_name: ObjectName::from(vec![Ident::new("accounts")]), referenced_table_name: None, referencing: vec![ TriggerReferencing { refer_type: TriggerReferencingType::NewTable, is_as: true, transition_relation_name: ObjectName::from(vec![Ident::new("new_accounts")]), }, TriggerReferencing { refer_type: TriggerReferencingType::OldTable, is_as: true, transition_relation_name: ObjectName::from(vec![Ident::new("old_accounts")]), }, ], trigger_object: Some(TriggerObjectKind::ForEach(TriggerObject::Row)), condition: None, exec_body: Some(TriggerExecBody { exec_type: TriggerExecBodyType::Function, func_desc: FunctionDesc { name: ObjectName::from(vec![Ident::new("check_account_referencing")]), args: None, }, }), statements_as: false, statements: None, characteristics: None, }); assert_eq!(pg().verified_stmt(sql), expected); } #[test] /// While in the parse_create_trigger test we test the full syntax of the CREATE TRIGGER statement, /// here we test the invalid cases of the CREATE TRIGGER statement which should cause an appropriate /// error to be returned. fn parse_create_trigger_invalid_cases() { // Test invalid cases for the CREATE TRIGGER statement let invalid_cases = vec![ ( "CREATE TRIGGER check_update BEFORE UPDATE ON accounts FUNCTION check_account_update", "Expected: an SQL statement, found: FUNCTION" ), ( "CREATE TRIGGER check_update TOMORROW UPDATE ON accounts EXECUTE FUNCTION check_account_update", "Expected: one of INSERT or UPDATE or DELETE or TRUNCATE, found: TOMORROW" ), ( "CREATE TRIGGER check_update BEFORE SAVE ON accounts EXECUTE FUNCTION check_account_update", "Expected: one of INSERT or UPDATE or DELETE or TRUNCATE, found: SAVE" ) ]; for (sql, expected_error) in invalid_cases { let res = pg().parse_sql_statements(sql); assert_eq!( format!("sql parser error: {expected_error}"), res.unwrap_err().to_string() ); } } #[test] fn parse_drop_trigger() { for if_exists in [true, false] { for option in [ None, Some(ReferentialAction::Cascade), Some(ReferentialAction::Restrict), ] { let sql = &format!( "DROP TRIGGER{} check_update ON table_name{}", if if_exists { " IF EXISTS" } else { "" }, option .map(|o| format!(" {o}")) .unwrap_or_else(|| "".to_string()) ); assert_eq!( pg().verified_stmt(sql), Statement::DropTrigger(DropTrigger { if_exists, trigger_name: ObjectName::from(vec![Ident::new("check_update")]), table_name: Some(ObjectName::from(vec![Ident::new("table_name")])), option }) ); } } } #[test] fn parse_drop_trigger_invalid_cases() { // Test invalid cases for the DROP TRIGGER statement let invalid_cases = vec![ ( "DROP TRIGGER check_update ON table_name CASCADE RESTRICT", "Expected: end of statement, found: RESTRICT", ), ( "DROP TRIGGER check_update ON table_name CASCADE CASCADE", "Expected: end of statement, found: CASCADE", ), ( "DROP TRIGGER check_update ON table_name CASCADE CASCADE CASCADE", "Expected: end of statement, found: CASCADE", ), ]; for (sql, expected_error) in invalid_cases { let res = pg().parse_sql_statements(sql); assert_eq!( format!("sql parser error: {expected_error}"), res.unwrap_err().to_string() ); } } #[test] fn parse_trigger_related_functions() { // First we define all parts of the trigger definition, // including the table creation, the function creation, the trigger creation and the trigger drop. // The following example is taken from the PostgreSQL documentation let sql_table_creation = r#" CREATE TABLE emp ( empname text, salary integer, last_date timestamp, last_user text ); "#; let sql_create_function = r#" CREATE FUNCTION emp_stamp() RETURNS trigger AS $emp_stamp$ BEGIN -- Check that empname and salary are given IF NEW.empname IS NULL THEN RAISE EXCEPTION 'empname cannot be null'; END IF; IF NEW.salary IS NULL THEN RAISE EXCEPTION '% cannot have null salary', NEW.empname; END IF; -- Who works for us when they must pay for it? IF NEW.salary < 0 THEN RAISE EXCEPTION '% cannot have a negative salary', NEW.empname; END IF; -- Remember who changed the payroll when NEW.last_date := current_timestamp; NEW.last_user := current_user; RETURN NEW; END; $emp_stamp$ LANGUAGE plpgsql; "#; let sql_create_trigger = r#" CREATE TRIGGER emp_stamp BEFORE INSERT OR UPDATE ON emp FOR EACH ROW EXECUTE FUNCTION emp_stamp(); "#; let sql_drop_trigger = r#" DROP TRIGGER emp_stamp ON emp; "#; // Now we parse the statements and check if they are parsed correctly. let mut statements = pg() .parse_sql_statements(&format!( "{sql_table_creation}{sql_create_function}{sql_create_trigger}{sql_drop_trigger}" )) .unwrap(); assert_eq!(statements.len(), 4); let drop_trigger = statements.pop().unwrap(); let create_trigger = statements.pop().unwrap(); let create_function = statements.pop().unwrap(); let create_table = statements.pop().unwrap(); // Check the first statement let create_table = match create_table { Statement::CreateTable(create_table) => create_table, _ => panic!("Expected CreateTable statement"), }; assert_eq!( create_table, CreateTable { or_replace: false, temporary: false, external: false, global: None, dynamic: false, if_not_exists: false, transient: false, volatile: false, iceberg: false, snapshot: false, name: ObjectName::from(vec![Ident::new("emp")]), columns: vec![ ColumnDef { name: "empname".into(), data_type: DataType::Text, options: vec![], }, ColumnDef { name: "salary".into(), data_type: DataType::Integer(None), options: vec![], }, ColumnDef { name: "last_date".into(), data_type: DataType::Timestamp(None, TimezoneInfo::None), options: vec![], }, ColumnDef { name: "last_user".into(), data_type: DataType::Text, options: vec![], }, ], constraints: vec![], hive_distribution: HiveDistributionStyle::NONE, hive_formats: None, file_format: None, location: None, query: None, without_rowid: false, like: None, clone: None, comment: None, on_commit: None, on_cluster: None, primary_key: None, order_by: None, partition_by: None, cluster_by: None, clustered_by: None, inherits: None, partition_of: None, for_values: None, strict: false, copy_grants: false, enable_schema_evolution: None, change_tracking: None, data_retention_time_in_days: None, max_data_extension_time_in_days: None, default_ddl_collation: None, with_aggregation_policy: None, with_row_access_policy: None, with_storage_lifecycle_policy: None, with_tags: None, base_location: None, external_volume: None, catalog: None, catalog_sync: None, storage_serialization_policy: None, table_options: CreateTableOptions::None, target_lag: None, warehouse: None, version: None, refresh_mode: None, initialize: None, require_user: false, diststyle: None, distkey: None, sortkey: None, backup: None, } ); // Check the second statement assert_eq!( create_function, Statement::CreateFunction(CreateFunction { or_alter: false, or_replace: false, temporary: false, if_not_exists: false, name: ObjectName::from(vec![Ident::new("emp_stamp")]), args: Some(vec![]), return_type: Some(FunctionReturnType::DataType(DataType::Trigger)), function_body: Some( CreateFunctionBody::AsBeforeOptions { body: Expr::Value(( Value::DollarQuotedString( DollarQuotedString { value: "\n BEGIN\n -- Check that empname and salary are given\n IF NEW.empname IS NULL THEN\n RAISE EXCEPTION 'empname cannot be null';\n END IF;\n IF NEW.salary IS NULL THEN\n RAISE EXCEPTION '% cannot have null salary', NEW.empname;\n END IF;\n\n -- Who works for us when they must pay for it?\n IF NEW.salary < 0 THEN\n RAISE EXCEPTION '% cannot have a negative salary', NEW.empname;\n END IF;\n\n -- Remember who changed the payroll when\n NEW.last_date := current_timestamp;\n NEW.last_user := current_user;\n RETURN NEW;\n END;\n ".to_owned(), tag: Some( "emp_stamp".to_owned(), ), }, ) ).with_empty_span()), link_symbol: None, }, ), behavior: None, called_on_null: None, parallel: None, security: None, set_params: vec![], using: None, language: Some(Ident::new("plpgsql")), determinism_specifier: None, options: None, remote_connection: None } )); // Check the third statement assert_eq!( create_trigger, Statement::CreateTrigger(CreateTrigger { or_alter: false, temporary: false, or_replace: false, is_constraint: false, name: ObjectName::from(vec![Ident::new("emp_stamp")]), period: Some(TriggerPeriod::Before), period_before_table: true, events: vec![TriggerEvent::Insert, TriggerEvent::Update(vec![])], table_name: ObjectName::from(vec![Ident::new("emp")]), referenced_table_name: None, referencing: vec![], trigger_object: Some(TriggerObjectKind::ForEach(TriggerObject::Row)), condition: None, exec_body: Some(TriggerExecBody { exec_type: TriggerExecBodyType::Function, func_desc: FunctionDesc { name: ObjectName::from(vec![Ident::new("emp_stamp")]), args: Some(vec![]), } }), statements_as: false, statements: None, characteristics: None }) ); // Check the fourth statement assert_eq!( drop_trigger, Statement::DropTrigger(DropTrigger { if_exists: false, trigger_name: ObjectName::from(vec![Ident::new("emp_stamp")]), table_name: Some(ObjectName::from(vec![Ident::new("emp")])), option: None }) ); } #[test] fn test_unicode_string_literal() { let pairs = [ // Example from the postgres docs (r#"U&'\0441\043B\043E\043D'"#, "слон"), // High unicode code point (> 0xFFFF) (r#"U&'\+01F418'"#, "🐘"), // Escaped backslash (r#"U&'\\'"#, r#"\"#), // Escaped single quote (r#"U&''''"#, "'"), ]; for (input, expected) in pairs { match pg_and_generic().verified_expr(input) { Expr::Value(ValueWithSpan { value: Value::UnicodeStringLiteral(s), span: _, }) => { assert_eq!(expected, s); } _ => unreachable!(), } } } fn check_arrow_precedence(sql: &str, arrow_operator: BinaryOperator) { assert_eq!( pg().verified_expr(sql), Expr::BinaryOp { left: Box::new(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident { value: "foo".to_string(), quote_style: None, span: Span::empty(), })), op: arrow_operator, right: Box::new(Expr::Value( (Value::SingleQuotedString("bar".to_string())).with_empty_span() )), }), op: BinaryOperator::Eq, right: Box::new(Expr::Value( (Value::SingleQuotedString("spam".to_string())).with_empty_span() )), } ) } #[test] fn arrow_precedence() { check_arrow_precedence("foo -> 'bar' = 'spam'", BinaryOperator::Arrow); } #[test] fn long_arrow_precedence() { check_arrow_precedence("foo ->> 'bar' = 'spam'", BinaryOperator::LongArrow); } #[test] fn arrow_cast_precedence() { // check this matches postgres where you would need `(foo -> 'bar')::TEXT` let stmt = pg().verified_expr("foo -> 'bar'::TEXT"); assert_eq!( stmt, Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident { value: "foo".to_string(), quote_style: None, span: Span::empty(), })), op: BinaryOperator::Arrow, right: Box::new(Expr::Cast { kind: CastKind::DoubleColon, expr: Box::new(Expr::Value( (Value::SingleQuotedString("bar".to_string())).with_empty_span() )), data_type: DataType::Text, array: false, format: None, }), } ) } #[test] fn parse_create_type_as_enum() { let sql = "CREATE TYPE public.my_type AS ENUM ('label1', 'label2', 'label3', 'label4')"; let statement = pg_and_generic().verified_stmt(sql); match statement { Statement::CreateType { name, representation: Some(UserDefinedTypeRepresentation::Enum { labels }), } => { assert_eq!("public.my_type", name.to_string()); assert_eq!( vec!["label1", "label2", "label3", "label4"] .into_iter() .map(|l| Ident::with_quote('\'', l)) .collect::>(), labels ); } _ => unreachable!("{:?} should parse to Statement::CreateType", sql), } } #[test] fn parse_alter_type() { struct TestCase { sql: &'static str, name: &'static str, operation: AlterTypeOperation, } vec![ TestCase { sql: "ALTER TYPE public.my_type RENAME TO my_new_type", name: "public.my_type", operation: AlterTypeOperation::Rename(AlterTypeRename { new_name: Ident::new("my_new_type"), }), }, TestCase { sql: "ALTER TYPE public.my_type ADD VALUE IF NOT EXISTS 'label3.5' BEFORE 'label4'", name: "public.my_type", operation: AlterTypeOperation::AddValue(AlterTypeAddValue { if_not_exists: true, value: Ident::with_quote('\'', "label3.5"), position: Some(AlterTypeAddValuePosition::Before(Ident::with_quote( '\'', "label4", ))), }), }, TestCase { sql: "ALTER TYPE public.my_type ADD VALUE 'label3.5' BEFORE 'label4'", name: "public.my_type", operation: AlterTypeOperation::AddValue(AlterTypeAddValue { if_not_exists: false, value: Ident::with_quote('\'', "label3.5"), position: Some(AlterTypeAddValuePosition::Before(Ident::with_quote( '\'', "label4", ))), }), }, TestCase { sql: "ALTER TYPE public.my_type ADD VALUE IF NOT EXISTS 'label3.5' AFTER 'label3'", name: "public.my_type", operation: AlterTypeOperation::AddValue(AlterTypeAddValue { if_not_exists: true, value: Ident::with_quote('\'', "label3.5"), position: Some(AlterTypeAddValuePosition::After(Ident::with_quote( '\'', "label3", ))), }), }, TestCase { sql: "ALTER TYPE public.my_type ADD VALUE 'label3.5' AFTER 'label3'", name: "public.my_type", operation: AlterTypeOperation::AddValue(AlterTypeAddValue { if_not_exists: false, value: Ident::with_quote('\'', "label3.5"), position: Some(AlterTypeAddValuePosition::After(Ident::with_quote( '\'', "label3", ))), }), }, TestCase { sql: "ALTER TYPE public.my_type ADD VALUE IF NOT EXISTS 'label5'", name: "public.my_type", operation: AlterTypeOperation::AddValue(AlterTypeAddValue { if_not_exists: true, value: Ident::with_quote('\'', "label5"), position: None, }), }, TestCase { sql: "ALTER TYPE public.my_type ADD VALUE 'label5'", name: "public.my_type", operation: AlterTypeOperation::AddValue(AlterTypeAddValue { if_not_exists: false, value: Ident::with_quote('\'', "label5"), position: None, }), }, ] .into_iter() .enumerate() .for_each(|(index, tc)| { let statement = pg_and_generic().verified_stmt(tc.sql); if let Statement::AlterType(AlterType { name, operation }) = statement { assert_eq!(tc.name, name.to_string(), "TestCase[{index}].name"); assert_eq!(tc.operation, operation, "TestCase[{index}].operation"); } else { unreachable!("{:?} should parse to Statement::AlterType", tc.sql); } }); } #[test] fn parse_bitstring_literal() { let select = pg_and_generic().verified_only_select("SELECT B'111'"); assert_eq!( select.projection, vec![SelectItem::UnnamedExpr(Expr::Value( (Value::SingleQuotedByteStringLiteral("111".to_string())).with_empty_span() ))] ); } #[test] fn parse_varbit_datatype() { match pg_and_generic().verified_stmt("CREATE TABLE foo (x VARBIT, y VARBIT(42))") { Statement::CreateTable(CreateTable { columns, .. }) => { assert_eq!( columns, vec![ ColumnDef { name: "x".into(), data_type: DataType::VarBit(None), options: vec![], }, ColumnDef { name: "y".into(), data_type: DataType::VarBit(Some(42)), options: vec![], } ] ); } _ => unreachable!(), } } #[test] fn parse_alter_table_replica_identity() { match pg_and_generic().verified_stmt("ALTER TABLE foo REPLICA IDENTITY FULL") { Statement::AlterTable(AlterTable { operations, .. }) => { assert_eq!( operations, vec![AlterTableOperation::ReplicaIdentity { identity: ReplicaIdentity::Full }] ); } _ => unreachable!(), } match pg_and_generic().verified_stmt("ALTER TABLE foo REPLICA IDENTITY USING INDEX foo_idx") { Statement::AlterTable(AlterTable { operations, .. }) => { assert_eq!( operations, vec![AlterTableOperation::ReplicaIdentity { identity: ReplicaIdentity::Index("foo_idx".into()) }] ); } _ => unreachable!(), } match pg_and_generic().verified_stmt("ALTER TABLE foo REPLICA IDENTITY NOTHING") { Statement::AlterTable(AlterTable { operations, .. }) => { assert_eq!( operations, vec![AlterTableOperation::ReplicaIdentity { identity: ReplicaIdentity::Nothing }] ); } _ => unreachable!(), } match pg_and_generic().verified_stmt("ALTER TABLE foo REPLICA IDENTITY DEFAULT") { Statement::AlterTable(AlterTable { operations, .. }) => { assert_eq!( operations, vec![AlterTableOperation::ReplicaIdentity { identity: ReplicaIdentity::Default }] ); } _ => unreachable!(), } } #[test] fn parse_ts_datatypes() { match pg_and_generic().verified_stmt("CREATE TABLE foo (x TSVECTOR)") { Statement::CreateTable(CreateTable { columns, .. }) => { assert_eq!( columns, vec![ColumnDef { name: "x".into(), data_type: DataType::TsVector, options: vec![], }] ); } _ => unreachable!(), } match pg_and_generic().verified_stmt("CREATE TABLE foo (x TSQUERY)") { Statement::CreateTable(CreateTable { columns, .. }) => { assert_eq!( columns, vec![ColumnDef { name: "x".into(), data_type: DataType::TsQuery, options: vec![], }] ); } _ => unreachable!(), } } #[test] fn parse_alter_table_constraint_not_valid() { match pg_and_generic().verified_stmt( "ALTER TABLE foo ADD CONSTRAINT bar FOREIGN KEY (baz) REFERENCES other(ref) NOT VALID", ) { Statement::AlterTable(AlterTable { operations, .. }) => { assert_eq!( operations, vec![AlterTableOperation::AddConstraint { constraint: ForeignKeyConstraint { name: Some("bar".into()), index_name: None, columns: vec!["baz".into()], foreign_table: ObjectName::from(vec!["other".into()]), referred_columns: vec!["ref".into()], on_delete: None, on_update: None, match_kind: None, characteristics: None, } .into(), not_valid: true, }] ); } _ => unreachable!(), } } #[test] fn parse_alter_table_validate_constraint() { match pg_and_generic().verified_stmt("ALTER TABLE foo VALIDATE CONSTRAINT bar") { Statement::AlterTable(AlterTable { operations, .. }) => { assert_eq!( operations, vec![AlterTableOperation::ValidateConstraint { name: "bar".into() }] ); } _ => unreachable!(), } } #[test] fn parse_create_server() { let test_cases = vec![ ( "CREATE SERVER myserver FOREIGN DATA WRAPPER postgres_fdw", CreateServerStatement { name: ObjectName::from(vec!["myserver".into()]), if_not_exists: false, server_type: None, version: None, foreign_data_wrapper: ObjectName::from(vec!["postgres_fdw".into()]), options: None, }, ), ( "CREATE SERVER IF NOT EXISTS myserver TYPE 'server_type' VERSION 'server_version' FOREIGN DATA WRAPPER postgres_fdw", CreateServerStatement { name: ObjectName::from(vec!["myserver".into()]), if_not_exists: true, server_type: Some(Ident { value: "server_type".to_string(), quote_style: Some('\''), span: Span::empty(), }), version: Some(Ident { value: "server_version".to_string(), quote_style: Some('\''), span: Span::empty(), }), foreign_data_wrapper: ObjectName::from(vec!["postgres_fdw".into()]), options: None, } ), ( "CREATE SERVER myserver2 FOREIGN DATA WRAPPER postgres_fdw OPTIONS (host 'foo', dbname 'foodb', port '5432')", CreateServerStatement { name: ObjectName::from(vec!["myserver2".into()]), if_not_exists: false, server_type: None, version: None, foreign_data_wrapper: ObjectName::from(vec!["postgres_fdw".into()]), options: Some(vec![ CreateServerOption { key: "host".into(), value: Ident { value: "foo".to_string(), quote_style: Some('\''), span: Span::empty(), }, }, CreateServerOption { key: "dbname".into(), value: Ident { value: "foodb".to_string(), quote_style: Some('\''), span: Span::empty(), }, }, CreateServerOption { key: "port".into(), value: Ident { value: "5432".to_string(), quote_style: Some('\''), span: Span::empty(), }, }, ]), } ) ]; for (sql, expected) in test_cases { let Statement::CreateServer(stmt) = pg_and_generic().verified_stmt(sql) else { unreachable!() }; assert_eq!(stmt, expected); } } #[test] fn parse_alter_schema() { // Test RENAME operation let stmt = pg_and_generic().verified_stmt("ALTER SCHEMA foo RENAME TO bar"); match stmt { Statement::AlterSchema(AlterSchema { operations, .. }) => { assert_eq!( operations, vec![AlterSchemaOperation::Rename { name: ObjectName::from(vec!["bar".into()]) }] ); } _ => unreachable!(), } // Test OWNER TO operations with different owner types for (owner_clause, expected_owner) in &[ ("bar", Owner::Ident("bar".into())), ("CURRENT_ROLE", Owner::CurrentRole), ("CURRENT_USER", Owner::CurrentUser), ("SESSION_USER", Owner::SessionUser), ] { let sql = format!("ALTER SCHEMA foo OWNER TO {}", owner_clause); let stmt = pg_and_generic().verified_stmt(&sql); match stmt { Statement::AlterSchema(AlterSchema { operations, .. }) => { assert_eq!( operations, vec![AlterSchemaOperation::OwnerTo { owner: expected_owner.clone() }] ); } _ => unreachable!(), } } } #[test] fn parse_foreign_key_match() { let test_cases = [ ("MATCH FULL", ConstraintReferenceMatchKind::Full), ("MATCH SIMPLE", ConstraintReferenceMatchKind::Simple), ("MATCH PARTIAL", ConstraintReferenceMatchKind::Partial), ]; for (match_clause, expected_kind) in test_cases { // Test column-level foreign key let sql = format!("CREATE TABLE t (id INT REFERENCES other_table (id) {match_clause})"); let statement = pg_and_generic().verified_stmt(&sql); match statement { Statement::CreateTable(CreateTable { columns, .. }) => { match &columns[0].options[0].option { ColumnOption::ForeignKey(constraint) => { assert_eq!(constraint.match_kind, Some(expected_kind)); } _ => panic!("Expected ColumnOption::ForeignKey"), } } _ => unreachable!("{:?} should parse to Statement::CreateTable", sql), } // Test table-level foreign key constraint let sql = format!( "CREATE TABLE t (id INT, FOREIGN KEY (id) REFERENCES other_table(id) {match_clause})" ); let statement = pg_and_generic().verified_stmt(&sql); match statement { Statement::CreateTable(CreateTable { constraints, .. }) => match &constraints[0] { TableConstraint::ForeignKey(constraint) => { assert_eq!(constraint.match_kind, Some(expected_kind)); } _ => panic!("Expected TableConstraint::ForeignKey"), }, _ => unreachable!("{:?} should parse to Statement::CreateTable", sql), } } } #[test] fn parse_foreign_key_match_with_actions() { let sql = "CREATE TABLE orders (order_id INT REFERENCES another_table (id) MATCH FULL ON DELETE CASCADE ON UPDATE RESTRICT, customer_id INT, CONSTRAINT fk_customer FOREIGN KEY (customer_id) REFERENCES customers(customer_id) MATCH SIMPLE ON DELETE SET NULL ON UPDATE CASCADE)"; pg_and_generic().verified_stmt(sql); } #[test] fn parse_create_operator() { let sql = "CREATE OPERATOR myschema.@@ (PROCEDURE = myschema.my_proc, LEFTARG = TIMESTAMP WITH TIME ZONE, RIGHTARG = VARCHAR(255), COMMUTATOR = schema.>, NEGATOR = schema.<=, RESTRICT = myschema.sel_func, JOIN = myschema.join_func, HASHES, MERGES)"; assert_eq!( pg().verified_stmt(sql), Statement::CreateOperator(CreateOperator { name: ObjectName::from(vec![Ident::new("myschema"), Ident::new("@@")]), function: ObjectName::from(vec![Ident::new("myschema"), Ident::new("my_proc")]), is_procedure: true, left_arg: Some(DataType::Timestamp(None, TimezoneInfo::WithTimeZone)), right_arg: Some(DataType::Varchar(Some(CharacterLength::IntegerLength { length: 255, unit: None }))), options: vec![ OperatorOption::Commutator(ObjectName::from(vec![ Ident::new("schema"), Ident::new(">") ])), OperatorOption::Negator(ObjectName::from(vec![ Ident::new("schema"), Ident::new("<=") ])), OperatorOption::Restrict(Some(ObjectName::from(vec![ Ident::new("myschema"), Ident::new("sel_func") ]))), OperatorOption::Join(Some(ObjectName::from(vec![ Ident::new("myschema"), Ident::new("join_func") ]))), OperatorOption::Hashes, OperatorOption::Merges, ], }) ); for op_symbol in &[ "-", "*", "/", "<", ">", "=", "<=", ">=", "<>", "~", "!", "@", "#", "%", "^", "&", "|", "<<", ">>", "&&", ] { assert_eq!( pg().verified_stmt(&format!("CREATE OPERATOR {op_symbol} (FUNCTION = f)")), Statement::CreateOperator(CreateOperator { name: ObjectName::from(vec![Ident::new(*op_symbol)]), function: ObjectName::from(vec![Ident::new("f")]), is_procedure: false, left_arg: None, right_arg: None, options: vec![], }) ); } pg().one_statement_parses_to( "CREATE OPERATOR != (FUNCTION = func)", "CREATE OPERATOR <> (FUNCTION = func)", ); for (name, expected_name) in [ ( "s1.+", ObjectName::from(vec![Ident::new("s1"), Ident::new("+")]), ), ( "s2.-", ObjectName::from(vec![Ident::new("s2"), Ident::new("-")]), ), ( "s1.s3.*", ObjectName::from(vec![Ident::new("s1"), Ident::new("s3"), Ident::new("*")]), ), ] { match pg().verified_stmt(&format!("CREATE OPERATOR {name} (FUNCTION = f)")) { Statement::CreateOperator(CreateOperator { name, options, .. }) => { assert_eq!(name, expected_name); assert!(options.is_empty()); } _ => unreachable!(), } } pg().one_statement_parses_to( "CREATE OPERATOR + (FUNCTION = f, COMMUTATOR = OPERATOR(>), NEGATOR = OPERATOR(>=))", "CREATE OPERATOR + (FUNCTION = f, COMMUTATOR = >, NEGATOR = >=)", ); // Test all duplicate clause errors for field in &[ "FUNCTION = f2", "PROCEDURE = p", "LEFTARG = INT4, LEFTARG = INT4", "RIGHTARG = INT4, RIGHTARG = INT4", "COMMUTATOR = -, COMMUTATOR = *", "NEGATOR = -, NEGATOR = *", "RESTRICT = f1, RESTRICT = f2", "JOIN = f1, JOIN = f2", "HASHES, HASHES", "MERGES, MERGES", ] { assert!(pg() .parse_sql_statements(&format!("CREATE OPERATOR + (FUNCTION = f, {field})")) .is_err()); } // Test missing FUNCTION/PROCEDURE error assert!(pg() .parse_sql_statements("CREATE OPERATOR + (LEFTARG = INT4)") .is_err()); // Test empty parameter list error assert!(pg().parse_sql_statements("CREATE OPERATOR + ()").is_err()); // Test nested empty parentheses error assert!(pg().parse_sql_statements("CREATE OPERATOR > (()").is_err()); assert!(pg().parse_sql_statements("CREATE OPERATOR > ())").is_err()); } #[test] fn parse_drop_operator() { // Test DROP OPERATOR with NONE for prefix operator let sql = "DROP OPERATOR ~ (NONE, BIT)"; assert_eq!( pg_and_generic().verified_stmt(sql), Statement::DropOperator(DropOperator { if_exists: false, operators: vec![DropOperatorSignature { name: ObjectName::from(vec![Ident::new("~")]), left_type: None, right_type: DataType::Bit(None), }], drop_behavior: None, }) ); for if_exist in [true, false] { for cascading in [ None, Some(DropBehavior::Cascade), Some(DropBehavior::Restrict), ] { for op in &["<", ">", "<=", ">=", "<>", "||", "&&", "<<", ">>"] { let sql = format!( "DROP OPERATOR{} {op} (INTEGER, INTEGER){}", if if_exist { " IF EXISTS" } else { "" }, match cascading { Some(cascading) => format!(" {cascading}"), None => String::new(), } ); assert_eq!( pg_and_generic().verified_stmt(&sql), Statement::DropOperator(DropOperator { if_exists: if_exist, operators: vec![DropOperatorSignature { name: ObjectName::from(vec![Ident::new(*op)]), left_type: Some(DataType::Integer(None)), right_type: DataType::Integer(None), }], drop_behavior: cascading, }) ); } } } // Test DROP OPERATOR with schema-qualified operator name let sql = "DROP OPERATOR myschema.@@ (TEXT, TEXT)"; assert_eq!( pg_and_generic().verified_stmt(sql), Statement::DropOperator(DropOperator { if_exists: false, operators: vec![DropOperatorSignature { name: ObjectName::from(vec![Ident::new("myschema"), Ident::new("@@")]), left_type: Some(DataType::Text), right_type: DataType::Text, }], drop_behavior: None, }) ); // Test DROP OPERATOR with multiple operators, IF EXISTS and CASCADE let sql = "DROP OPERATOR IF EXISTS + (INTEGER, INTEGER), - (INTEGER, INTEGER) CASCADE"; assert_eq!( pg_and_generic().verified_stmt(sql), Statement::DropOperator(DropOperator { if_exists: true, operators: vec![ DropOperatorSignature { name: ObjectName::from(vec![Ident::new("+")]), left_type: Some(DataType::Integer(None)), right_type: DataType::Integer(None), }, DropOperatorSignature { name: ObjectName::from(vec![Ident::new("-")]), left_type: Some(DataType::Integer(None)), right_type: DataType::Integer(None), } ], drop_behavior: Some(DropBehavior::Cascade), }) ); // Test error: DROP OPERATOR with no operators let sql = "DROP OPERATOR (INTEGER, INTEGER)"; assert!(pg().parse_sql_statements(sql).is_err()); // Test error: DROP OPERATOR IF EXISTS with no operators let sql = "DROP OPERATOR IF EXISTS (INTEGER, INTEGER)"; assert!(pg().parse_sql_statements(sql).is_err()); } #[test] fn parse_alter_operator() { use sqlparser::ast::{AlterOperator, AlterOperatorOperation, OperatorOption, Owner}; // Test ALTER OPERATOR ... OWNER TO with different owner types for (owner_sql, owner_ast) in [ ("joe", Owner::Ident(Ident::new("joe"))), ("CURRENT_USER", Owner::CurrentUser), ("CURRENT_ROLE", Owner::CurrentRole), ("SESSION_USER", Owner::SessionUser), ] { for (op_name, op_name_ast, left_type_sql, left_type_ast, right_type_sql, right_type_ast) in [ ( "+", ObjectName::from(vec![Ident::new("+")]), "INTEGER", Some(DataType::Integer(None)), "INTEGER", DataType::Integer(None), ), ( "~", ObjectName::from(vec![Ident::new("~")]), "NONE", None, "BIT", DataType::Bit(None), ), ( "@@", ObjectName::from(vec![Ident::new("@@")]), "TEXT", Some(DataType::Text), "TEXT", DataType::Text, ), ] { let sql = format!( "ALTER OPERATOR {} ({}, {}) OWNER TO {}", op_name, left_type_sql, right_type_sql, owner_sql ); assert_eq!( pg_and_generic().verified_stmt(&sql), Statement::AlterOperator(AlterOperator { name: op_name_ast.clone(), left_type: left_type_ast.clone(), right_type: right_type_ast.clone(), operation: AlterOperatorOperation::OwnerTo(owner_ast.clone()), }) ); } } // Test ALTER OPERATOR ... SET SCHEMA for (op_name, op_name_ast, schema_name, schema_name_ast) in [ ( "+", ObjectName::from(vec![Ident::new("+")]), "new_schema", ObjectName::from(vec![Ident::new("new_schema")]), ), ( "myschema.@@", ObjectName::from(vec![Ident::new("myschema"), Ident::new("@@")]), "other_schema", ObjectName::from(vec![Ident::new("other_schema")]), ), ] { let sql = format!( "ALTER OPERATOR {} (TEXT, TEXT) SET SCHEMA {}", op_name, schema_name ); assert_eq!( pg_and_generic().verified_stmt(&sql), Statement::AlterOperator(AlterOperator { name: op_name_ast, left_type: Some(DataType::Text), right_type: DataType::Text, operation: AlterOperatorOperation::SetSchema { schema_name: schema_name_ast, }, }) ); } // Test ALTER OPERATOR ... SET with RESTRICT and JOIN for (restrict_val, restrict_ast, join_val, join_ast) in [ ( "_int_contsel", Some(ObjectName::from(vec![Ident::new("_int_contsel")])), "_int_contjoinsel", Some(ObjectName::from(vec![Ident::new("_int_contjoinsel")])), ), ( "NONE", None, "my_joinsel", Some(ObjectName::from(vec![Ident::new("my_joinsel")])), ), ( "my_sel", Some(ObjectName::from(vec![Ident::new("my_sel")])), "NONE", None, ), ] { let sql = format!( "ALTER OPERATOR && (TEXT, TEXT) SET (RESTRICT = {}, JOIN = {})", restrict_val, join_val ); assert_eq!( pg_and_generic().verified_stmt(&sql), Statement::AlterOperator(AlterOperator { name: ObjectName::from(vec![Ident::new("&&")]), left_type: Some(DataType::Text), right_type: DataType::Text, operation: AlterOperatorOperation::Set { options: vec![ OperatorOption::Restrict(restrict_ast), OperatorOption::Join(join_ast), ], }, }) ); } // Test ALTER OPERATOR ... SET with COMMUTATOR and NEGATOR for (operator, commutator, negator) in [("&&", "&&", ">"), ("+", "+", "-"), ("<", "<", ">=")] { let sql = format!( "ALTER OPERATOR {} (INTEGER, INTEGER) SET (COMMUTATOR = {}, NEGATOR = {})", operator, commutator, negator ); assert_eq!( pg_and_generic().verified_stmt(&sql), Statement::AlterOperator(AlterOperator { name: ObjectName::from(vec![Ident::new(operator)]), left_type: Some(DataType::Integer(None)), right_type: DataType::Integer(None), operation: AlterOperatorOperation::Set { options: vec![ OperatorOption::Commutator(ObjectName::from(vec![Ident::new(commutator)])), OperatorOption::Negator(ObjectName::from(vec![Ident::new(negator)])), ], }, }) ); } // Test ALTER OPERATOR ... SET with HASHES and MERGES (individually and combined) for (operator, options_sql, options_ast) in [ ("=", "HASHES", vec![OperatorOption::Hashes]), ("<", "MERGES", vec![OperatorOption::Merges]), ( "<=", "HASHES, MERGES", vec![OperatorOption::Hashes, OperatorOption::Merges], ), ] { let sql = format!( "ALTER OPERATOR {} (INTEGER, INTEGER) SET ({})", operator, options_sql ); assert_eq!( pg_and_generic().verified_stmt(&sql), Statement::AlterOperator(AlterOperator { name: ObjectName::from(vec![Ident::new(operator)]), left_type: Some(DataType::Integer(None)), right_type: DataType::Integer(None), operation: AlterOperatorOperation::Set { options: options_ast }, }) ); } // Test ALTER OPERATOR ... SET with multiple options combined let sql = "ALTER OPERATOR + (INTEGER, INTEGER) SET (COMMUTATOR = +, NEGATOR = -, HASHES, MERGES)"; assert_eq!( pg_and_generic().verified_stmt(sql), Statement::AlterOperator(AlterOperator { name: ObjectName::from(vec![Ident::new("+")]), left_type: Some(DataType::Integer(None)), right_type: DataType::Integer(None), operation: AlterOperatorOperation::Set { options: vec![ OperatorOption::Commutator(ObjectName::from(vec![Ident::new("+")])), OperatorOption::Negator(ObjectName::from(vec![Ident::new("-")])), OperatorOption::Hashes, OperatorOption::Merges, ], }, }) ); } #[test] fn parse_alter_operator_family() { // Test ALTER OPERATOR FAMILY ... ADD OPERATOR let sql = "ALTER OPERATOR FAMILY integer_ops USING btree ADD OPERATOR 1 < (INT4, INT2)"; assert_eq!( pg_and_generic().verified_stmt(sql), Statement::AlterOperatorFamily(AlterOperatorFamily { name: ObjectName::from(vec![Ident::new("integer_ops")]), using: Ident::new("btree"), operation: AlterOperatorFamilyOperation::Add { items: vec![OperatorFamilyItem::Operator { strategy_number: 1, operator_name: ObjectName::from(vec![Ident::new("<")]), op_types: vec![DataType::Int4(None), DataType::Int2(None)], purpose: None, }], }, }) ); // Test ALTER OPERATOR FAMILY ... ADD OPERATOR with FOR SEARCH let sql = "ALTER OPERATOR FAMILY text_ops USING btree ADD OPERATOR 1 @@ (TEXT, TEXT) FOR SEARCH"; assert_eq!( pg_and_generic().verified_stmt(sql), Statement::AlterOperatorFamily(AlterOperatorFamily { name: ObjectName::from(vec![Ident::new("text_ops")]), using: Ident::new("btree"), operation: AlterOperatorFamilyOperation::Add { items: vec![OperatorFamilyItem::Operator { strategy_number: 1, operator_name: ObjectName::from(vec![Ident::new("@@")]), op_types: vec![DataType::Text, DataType::Text], purpose: Some(OperatorPurpose::ForSearch), }], }, }) ); // Test ALTER OPERATOR FAMILY ... ADD FUNCTION let sql = "ALTER OPERATOR FAMILY integer_ops USING btree ADD FUNCTION 1 btint42cmp(INT4, INT2)"; assert_eq!( pg_and_generic().verified_stmt(sql), Statement::AlterOperatorFamily(AlterOperatorFamily { name: ObjectName::from(vec![Ident::new("integer_ops")]), using: Ident::new("btree"), operation: AlterOperatorFamilyOperation::Add { items: vec![OperatorFamilyItem::Function { support_number: 1, op_types: None, function_name: ObjectName::from(vec![Ident::new("btint42cmp")]), argument_types: vec![DataType::Int4(None), DataType::Int2(None)], }], }, }) ); // Test ALTER OPERATOR FAMILY ... DROP OPERATOR let sql = "ALTER OPERATOR FAMILY integer_ops USING btree DROP OPERATOR 1 (INT4, INT2)"; assert_eq!( pg_and_generic().verified_stmt(sql), Statement::AlterOperatorFamily(AlterOperatorFamily { name: ObjectName::from(vec![Ident::new("integer_ops")]), using: Ident::new("btree"), operation: AlterOperatorFamilyOperation::Drop { items: vec![OperatorFamilyDropItem::Operator { strategy_number: 1, op_types: vec![DataType::Int4(None), DataType::Int2(None)], }], }, }) ); // Test ALTER OPERATOR FAMILY ... DROP FUNCTION let sql = "ALTER OPERATOR FAMILY integer_ops USING btree DROP FUNCTION 1 (INT4, INT2)"; assert_eq!( pg_and_generic().verified_stmt(sql), Statement::AlterOperatorFamily(AlterOperatorFamily { name: ObjectName::from(vec![Ident::new("integer_ops")]), using: Ident::new("btree"), operation: AlterOperatorFamilyOperation::Drop { items: vec![OperatorFamilyDropItem::Function { support_number: 1, op_types: vec![DataType::Int4(None), DataType::Int2(None)], }], }, }) ); // Test ALTER OPERATOR FAMILY ... RENAME TO let sql = "ALTER OPERATOR FAMILY old_ops USING btree RENAME TO new_ops"; assert_eq!( pg_and_generic().verified_stmt(sql), Statement::AlterOperatorFamily(AlterOperatorFamily { name: ObjectName::from(vec![Ident::new("old_ops")]), using: Ident::new("btree"), operation: AlterOperatorFamilyOperation::RenameTo { new_name: ObjectName::from(vec![Ident::new("new_ops")]), }, }) ); // Test ALTER OPERATOR FAMILY ... OWNER TO let sql = "ALTER OPERATOR FAMILY my_ops USING btree OWNER TO joe"; assert_eq!( pg_and_generic().verified_stmt(sql), Statement::AlterOperatorFamily(AlterOperatorFamily { name: ObjectName::from(vec![Ident::new("my_ops")]), using: Ident::new("btree"), operation: AlterOperatorFamilyOperation::OwnerTo(Owner::Ident(Ident::new("joe"))), }) ); // Test ALTER OPERATOR FAMILY ... SET SCHEMA let sql = "ALTER OPERATOR FAMILY my_ops USING btree SET SCHEMA new_schema"; assert_eq!( pg_and_generic().verified_stmt(sql), Statement::AlterOperatorFamily(AlterOperatorFamily { name: ObjectName::from(vec![Ident::new("my_ops")]), using: Ident::new("btree"), operation: AlterOperatorFamilyOperation::SetSchema { schema_name: ObjectName::from(vec![Ident::new("new_schema")]), }, }) ); // Test error cases // Missing USING clause assert!(pg() .parse_sql_statements("ALTER OPERATOR FAMILY my_ops ADD OPERATOR 1 < (INT4, INT2)") .is_err()); // Invalid operation assert!(pg() .parse_sql_statements("ALTER OPERATOR FAMILY my_ops USING btree INVALID_OPERATION") .is_err()); // Missing operator name in ADD OPERATOR assert!(pg() .parse_sql_statements( "ALTER OPERATOR FAMILY my_ops USING btree ADD OPERATOR 1 (INT4, INT2)" ) .is_err()); // Missing function name in ADD FUNCTION assert!(pg() .parse_sql_statements( "ALTER OPERATOR FAMILY my_ops USING btree ADD FUNCTION 1 (INT4, INT2)" ) .is_err()); // Missing parentheses in DROP OPERATOR assert!(pg() .parse_sql_statements("ALTER OPERATOR FAMILY my_ops USING btree DROP OPERATOR 1 INT4, INT2") .is_err()); // Invalid operator name (empty) assert!(pg() .parse_sql_statements( "ALTER OPERATOR FAMILY my_ops USING btree ADD OPERATOR 1 (INT4, INT2)" ) .is_err()); // Invalid operator name (special characters) assert!(pg() .parse_sql_statements( "ALTER OPERATOR FAMILY my_ops USING btree ADD OPERATOR 1 @#$ (INT4, INT2)" ) .is_err()); // Negative strategy number assert!(pg() .parse_sql_statements( "ALTER OPERATOR FAMILY my_ops USING btree ADD OPERATOR -1 < (INT4, INT2)" ) .is_err()); // Non-integer strategy number assert!(pg() .parse_sql_statements( "ALTER OPERATOR FAMILY my_ops USING btree ADD OPERATOR 1.5 < (INT4, INT2)" ) .is_err()); // Missing closing parenthesis in operator types assert!(pg() .parse_sql_statements( "ALTER OPERATOR FAMILY my_ops USING btree ADD OPERATOR 1 < (INT4, INT2" ) .is_err()); // Missing opening parenthesis in operator types assert!(pg() .parse_sql_statements( "ALTER OPERATOR FAMILY my_ops USING btree ADD OPERATOR 1 < INT4, INT2)" ) .is_err()); // Empty operator types assert!(pg() .parse_sql_statements("ALTER OPERATOR FAMILY my_ops USING btree ADD OPERATOR 1 < ()") .is_err()); // Invalid data type (using punctuation) assert!(pg() .parse_sql_statements( "ALTER OPERATOR FAMILY my_ops USING btree ADD OPERATOR 1 < (@#$%, INT2)" ) .is_err()); // Incomplete FOR clause assert!(pg() .parse_sql_statements( "ALTER OPERATOR FAMILY my_ops USING btree ADD OPERATOR 1 < (INT4, INT2) FOR" ) .is_err()); // Invalid FOR clause keyword assert!(pg() .parse_sql_statements( "ALTER OPERATOR FAMILY my_ops USING btree ADD OPERATOR 1 < (INT4, INT2) FOR INVALID" ) .is_err()); // FOR ORDER BY without sort family assert!(pg() .parse_sql_statements( "ALTER OPERATOR FAMILY my_ops USING btree ADD OPERATOR 1 < (INT4, INT2) FOR ORDER BY" ) .is_err()); // Missing function name in ADD FUNCTION assert!(pg() .parse_sql_statements( "ALTER OPERATOR FAMILY my_ops USING btree ADD FUNCTION 1 (INT4, INT2)" ) .is_err()); // Invalid function name assert!(pg() .parse_sql_statements( "ALTER OPERATOR FAMILY my_ops USING btree ADD FUNCTION 1 123invalid(INT4, INT2)" ) .is_err()); // Negative support number assert!(pg() .parse_sql_statements( "ALTER OPERATOR FAMILY my_ops USING btree ADD FUNCTION -1 func(INT4, INT2)" ) .is_err()); // Non-integer support number assert!(pg() .parse_sql_statements( "ALTER OPERATOR FAMILY my_ops USING btree ADD FUNCTION 1.5 func(INT4, INT2)" ) .is_err()); // Missing closing parenthesis in function operator types assert!(pg() .parse_sql_statements( "ALTER OPERATOR FAMILY my_ops USING btree ADD FUNCTION 1 (INT4, INT2 func()" ) .is_err()); // Missing closing parenthesis in function arguments assert!(pg() .parse_sql_statements( "ALTER OPERATOR FAMILY my_ops USING btree ADD FUNCTION 1 func(INT4, INT2" ) .is_err()); // Invalid data type in function arguments assert!(pg() .parse_sql_statements( "ALTER OPERATOR FAMILY my_ops USING btree ADD FUNCTION 1 func(@#$%, INT2)" ) .is_err()); // DROP OPERATOR with FOR clause (not allowed) assert!(pg() .parse_sql_statements( "ALTER OPERATOR FAMILY my_ops USING btree DROP OPERATOR 1 (INT4, INT2) FOR SEARCH" ) .is_err()); // DROP FUNCTION with function arguments (not allowed) assert!(pg() .parse_sql_statements( "ALTER OPERATOR FAMILY my_ops USING btree DROP FUNCTION 1 (INT4, INT2) func(INT4)" ) .is_err()); // Multiple ADD items with error in middle assert!(pg() .parse_sql_statements( "ALTER OPERATOR FAMILY my_ops USING btree ADD OPERATOR 1 < (INT4, INT2), INVALID_ITEM" ) .is_err()); // Multiple DROP items with error in middle assert!(pg() .parse_sql_statements( "ALTER OPERATOR FAMILY my_ops USING btree DROP OPERATOR 1 (INT4, INT2), INVALID_ITEM" ) .is_err()); // RENAME TO with invalid new name assert!(pg() .parse_sql_statements("ALTER OPERATOR FAMILY my_ops USING btree RENAME TO 123invalid") .is_err()); // OWNER TO with invalid owner assert!(pg() .parse_sql_statements("ALTER OPERATOR FAMILY my_ops USING btree OWNER TO 123invalid") .is_err()); // SET SCHEMA with invalid schema name assert!(pg() .parse_sql_statements("ALTER OPERATOR FAMILY my_ops USING btree SET SCHEMA 123invalid") .is_err()); // Schema-qualified operator family name with invalid schema assert!(pg() .parse_sql_statements( "ALTER OPERATOR FAMILY 123invalid.my_ops USING btree ADD OPERATOR 1 < (INT4, INT2)" ) .is_err()); // Missing operator family name assert!(pg() .parse_sql_statements("ALTER OPERATOR FAMILY USING btree ADD OPERATOR 1 < (INT4, INT2)") .is_err()); // Extra tokens at end assert!(pg() .parse_sql_statements( "ALTER OPERATOR FAMILY my_ops USING btree ADD OPERATOR 1 < (INT4, INT2) EXTRA" ) .is_err()); // Incomplete statement assert!(pg() .parse_sql_statements("ALTER OPERATOR FAMILY my_ops USING btree ADD") .is_err()); // Very long numbers assert!(pg() .parse_sql_statements("ALTER OPERATOR FAMILY my_ops USING btree ADD OPERATOR 999999999999999999999 < (INT4, INT2)") .is_err()); // Multiple FOR clauses assert!(pg() .parse_sql_statements("ALTER OPERATOR FAMILY my_ops USING btree ADD OPERATOR 1 < (INT4, INT2) FOR SEARCH FOR ORDER BY sort_family") .is_err()); // FOR SEARCH with extra tokens assert!(pg() .parse_sql_statements("ALTER OPERATOR FAMILY my_ops USING btree ADD OPERATOR 1 < (INT4, INT2) FOR SEARCH EXTRA") .is_err()); // FOR ORDER BY with invalid sort family assert!(pg() .parse_sql_statements("ALTER OPERATOR FAMILY my_ops USING btree ADD OPERATOR 1 < (INT4, INT2) FOR ORDER BY 123invalid") .is_err()); // Function with empty operator types but missing function args parens assert!(pg() .parse_sql_statements("ALTER OPERATOR FAMILY my_ops USING btree ADD FUNCTION 1 () func") .is_err()); // Function with mismatched parentheses assert!(pg() .parse_sql_statements( "ALTER OPERATOR FAMILY my_ops USING btree ADD FUNCTION 1 (INT4 func(INT2" ) .is_err()); // DROP with empty types assert!(pg() .parse_sql_statements("ALTER OPERATOR FAMILY my_ops USING btree DROP OPERATOR 1 ()") .is_err()); // DROP FUNCTION with empty types assert!(pg() .parse_sql_statements("ALTER OPERATOR FAMILY my_ops USING btree DROP FUNCTION 1 ()") .is_err()); } #[test] fn parse_alter_operator_class() { // Test ALTER OPERATOR CLASS ... RENAME TO let sql = "ALTER OPERATOR CLASS int_ops USING btree RENAME TO integer_ops"; assert_eq!( pg_and_generic().verified_stmt(sql), Statement::AlterOperatorClass(AlterOperatorClass { name: ObjectName::from(vec![Ident::new("int_ops")]), using: Ident::new("btree"), operation: AlterOperatorClassOperation::RenameTo { new_name: ObjectName::from(vec![Ident::new("integer_ops")]), }, }) ); // Test ALTER OPERATOR CLASS ... OWNER TO let sql = "ALTER OPERATOR CLASS int_ops USING btree OWNER TO joe"; assert_eq!( pg_and_generic().verified_stmt(sql), Statement::AlterOperatorClass(AlterOperatorClass { name: ObjectName::from(vec![Ident::new("int_ops")]), using: Ident::new("btree"), operation: AlterOperatorClassOperation::OwnerTo(Owner::Ident(Ident::new("joe"))), }) ); // Test ALTER OPERATOR CLASS ... OWNER TO CURRENT_USER let sql = "ALTER OPERATOR CLASS int_ops USING btree OWNER TO CURRENT_USER"; assert_eq!( pg_and_generic().verified_stmt(sql), Statement::AlterOperatorClass(AlterOperatorClass { name: ObjectName::from(vec![Ident::new("int_ops")]), using: Ident::new("btree"), operation: AlterOperatorClassOperation::OwnerTo(Owner::CurrentUser), }) ); // Test ALTER OPERATOR CLASS ... SET SCHEMA let sql = "ALTER OPERATOR CLASS int_ops USING btree SET SCHEMA new_schema"; assert_eq!( pg_and_generic().verified_stmt(sql), Statement::AlterOperatorClass(AlterOperatorClass { name: ObjectName::from(vec![Ident::new("int_ops")]), using: Ident::new("btree"), operation: AlterOperatorClassOperation::SetSchema { schema_name: ObjectName::from(vec![Ident::new("new_schema")]), }, }) ); // Test with schema-qualified operator class name let sql = "ALTER OPERATOR CLASS myschema.int_ops USING btree RENAME TO integer_ops"; assert_eq!( pg_and_generic().verified_stmt(sql), Statement::AlterOperatorClass(AlterOperatorClass { name: ObjectName::from(vec![Ident::new("myschema"), Ident::new("int_ops")]), using: Ident::new("btree"), operation: AlterOperatorClassOperation::RenameTo { new_name: ObjectName::from(vec![Ident::new("integer_ops")]), }, }) ); // Test with different index methods for index_method in &["hash", "gist", "gin", "spgist", "brin"] { let sql = format!( "ALTER OPERATOR CLASS int_ops USING {} RENAME TO integer_ops", index_method ); pg_and_generic().verified_stmt(&sql); } // Test error cases // Missing USING clause assert!(pg() .parse_sql_statements("ALTER OPERATOR CLASS int_ops RENAME TO integer_ops") .is_err()); // Invalid operation assert!(pg() .parse_sql_statements("ALTER OPERATOR CLASS int_ops USING btree INVALID_OPERATION") .is_err()); // Missing new name for RENAME TO assert!(pg() .parse_sql_statements("ALTER OPERATOR CLASS int_ops USING btree RENAME TO") .is_err()); // Missing owner for OWNER TO assert!(pg() .parse_sql_statements("ALTER OPERATOR CLASS int_ops USING btree OWNER TO") .is_err()); // Missing schema for SET SCHEMA assert!(pg() .parse_sql_statements("ALTER OPERATOR CLASS int_ops USING btree SET SCHEMA") .is_err()); // Invalid new name assert!(pg() .parse_sql_statements("ALTER OPERATOR CLASS int_ops USING btree RENAME TO 123invalid") .is_err()); // Invalid owner assert!(pg() .parse_sql_statements("ALTER OPERATOR CLASS int_ops USING btree OWNER TO 123invalid") .is_err()); // Invalid schema name assert!(pg() .parse_sql_statements("ALTER OPERATOR CLASS int_ops USING btree SET SCHEMA 123invalid") .is_err()); // Missing operator class name assert!(pg() .parse_sql_statements("ALTER OPERATOR CLASS USING btree RENAME TO integer_ops") .is_err()); // Extra tokens at end assert!(pg() .parse_sql_statements( "ALTER OPERATOR CLASS int_ops USING btree RENAME TO integer_ops EXTRA" ) .is_err()); // Missing index method assert!(pg() .parse_sql_statements("ALTER OPERATOR CLASS int_ops RENAME TO integer_ops") .is_err()); // Invalid index method assert!(pg() .parse_sql_statements("ALTER OPERATOR CLASS int_ops USING 123invalid RENAME TO integer_ops") .is_err()); // Trying to use ADD operation (only valid for OPERATOR FAMILY) assert!(pg() .parse_sql_statements( "ALTER OPERATOR CLASS int_ops USING btree ADD OPERATOR 1 < (INT4, INT2)" ) .is_err()); // Trying to use DROP operation (only valid for OPERATOR FAMILY) assert!(pg() .parse_sql_statements( "ALTER OPERATOR CLASS int_ops USING btree DROP OPERATOR 1 (INT4, INT2)" ) .is_err()); } #[test] fn parse_alter_function_and_aggregate() { for (sql, expected) in [ ( "ALTER AGGREGATE alt_func1(int) RENAME TO alt_func3", "ALTER AGGREGATE alt_func1(INT) RENAME TO alt_func3", ), ( "ALTER AGGREGATE alt_func1(int) OWNER TO regress_alter_generic_user3", "ALTER AGGREGATE alt_func1(INT) OWNER TO regress_alter_generic_user3", ), ( "ALTER AGGREGATE alt_func1(int) SET SCHEMA alt_nsp2", "ALTER AGGREGATE alt_func1(INT) SET SCHEMA alt_nsp2", ), ( "ALTER AGGREGATE alt_agg1(int) RENAME TO alt_agg2", "ALTER AGGREGATE alt_agg1(INT) RENAME TO alt_agg2", ), ( "ALTER AGGREGATE alt_agg1(int) RENAME TO alt_agg3", "ALTER AGGREGATE alt_agg1(INT) RENAME TO alt_agg3", ), ( "ALTER AGGREGATE alt_agg2(int) OWNER TO regress_alter_generic_user2", "ALTER AGGREGATE alt_agg2(INT) OWNER TO regress_alter_generic_user2", ), ( "ALTER AGGREGATE alt_agg2(int) OWNER TO regress_alter_generic_user3", "ALTER AGGREGATE alt_agg2(INT) OWNER TO regress_alter_generic_user3", ), ( "ALTER AGGREGATE alt_agg2(int) SET SCHEMA alt_nsp2", "ALTER AGGREGATE alt_agg2(INT) SET SCHEMA alt_nsp2", ), ( "ALTER AGGREGATE alt_order(int ORDER BY text) RENAME TO alt_order2", "ALTER AGGREGATE alt_order(INT ORDER BY TEXT) RENAME TO alt_order2", ), ( "ALTER AGGREGATE alt_order_only(ORDER BY int) SET SCHEMA alt_nsp2", "ALTER AGGREGATE alt_order_only(ORDER BY INT) SET SCHEMA alt_nsp2", ), ( "ALTER AGGREGATE alt_star(*) OWNER TO regress_alter_generic_user2", "ALTER AGGREGATE alt_star(*) OWNER TO regress_alter_generic_user2", ), ] { let statement = pg_and_generic().one_statement_parses_to(sql, expected); assert!(matches!( statement, Statement::AlterFunction(AlterFunction { kind: AlterFunctionKind::Aggregate, .. }) )); } for (sql, expected) in [ ( "ALTER FUNCTION alt_func1(int) RENAME TO alt_func2", "ALTER FUNCTION alt_func1(INT) RENAME TO alt_func2", ), ( "ALTER FUNCTION alt_func1(int) RENAME TO alt_func3", "ALTER FUNCTION alt_func1(INT) RENAME TO alt_func3", ), ( "ALTER FUNCTION alt_func2(int) OWNER TO regress_alter_generic_user2", "ALTER FUNCTION alt_func2(INT) OWNER TO regress_alter_generic_user2", ), ( "ALTER FUNCTION alt_func2(int) OWNER TO regress_alter_generic_user3", "ALTER FUNCTION alt_func2(INT) OWNER TO regress_alter_generic_user3", ), ( "ALTER FUNCTION alt_func2(int) SET SCHEMA alt_nsp1", "ALTER FUNCTION alt_func2(INT) SET SCHEMA alt_nsp1", ), ( "ALTER FUNCTION alt_func2(int) SET SCHEMA alt_nsp2", "ALTER FUNCTION alt_func2(INT) SET SCHEMA alt_nsp2", ), ( "ALTER FUNCTION alt_func2(int) DEPENDS ON EXTENSION ext1", "ALTER FUNCTION alt_func2(INT) DEPENDS ON EXTENSION ext1", ), ( "ALTER FUNCTION alt_func2(int) NO DEPENDS ON EXTENSION ext1", "ALTER FUNCTION alt_func2(INT) NO DEPENDS ON EXTENSION ext1", ), ( "ALTER FUNCTION alt_func2 IMMUTABLE", "ALTER FUNCTION alt_func2 IMMUTABLE", ), ( "ALTER FUNCTION alt_func2(int) IMMUTABLE", "ALTER FUNCTION alt_func2(INT) IMMUTABLE", ), ( "ALTER FUNCTION alt_func2(int) STABLE", "ALTER FUNCTION alt_func2(INT) STABLE", ), ( "ALTER FUNCTION alt_func2(int) VOLATILE", "ALTER FUNCTION alt_func2(INT) VOLATILE", ), ( "ALTER FUNCTION alt_func2(int) CALLED ON NULL INPUT", "ALTER FUNCTION alt_func2(INT) CALLED ON NULL INPUT", ), ( "ALTER FUNCTION alt_func2(int) RETURNS NULL ON NULL INPUT", "ALTER FUNCTION alt_func2(INT) RETURNS NULL ON NULL INPUT", ), ( "ALTER FUNCTION alt_func2(int) STRICT", "ALTER FUNCTION alt_func2(INT) STRICT", ), ( "ALTER FUNCTION alt_func2(int) LEAKPROOF", "ALTER FUNCTION alt_func2(INT) LEAKPROOF", ), ( "ALTER FUNCTION alt_func2(int) NOT LEAKPROOF", "ALTER FUNCTION alt_func2(INT) NOT LEAKPROOF", ), ( "ALTER FUNCTION alt_func2(int) SECURITY DEFINER", "ALTER FUNCTION alt_func2(INT) SECURITY DEFINER", ), ( "ALTER FUNCTION alt_func2(int) EXTERNAL SECURITY INVOKER", "ALTER FUNCTION alt_func2(INT) EXTERNAL SECURITY INVOKER", ), ( "ALTER FUNCTION alt_func2(int) PARALLEL SAFE", "ALTER FUNCTION alt_func2(INT) PARALLEL SAFE", ), ( "ALTER FUNCTION alt_func2(int) PARALLEL RESTRICTED", "ALTER FUNCTION alt_func2(INT) PARALLEL RESTRICTED", ), ( "ALTER FUNCTION alt_func2(int) PARALLEL UNSAFE", "ALTER FUNCTION alt_func2(INT) PARALLEL UNSAFE", ), ( "ALTER FUNCTION alt_func2(int) COST 3.5", "ALTER FUNCTION alt_func2(INT) COST 3.5", ), ( "ALTER FUNCTION alt_func2(int) ROWS 42", "ALTER FUNCTION alt_func2(INT) ROWS 42", ), ( "ALTER FUNCTION alt_func2(int) SUPPORT pg_catalog.alt_support", "ALTER FUNCTION alt_func2(INT) SUPPORT pg_catalog.alt_support", ), ( "ALTER FUNCTION alt_func2(int) SET work_mem TO DEFAULT", "ALTER FUNCTION alt_func2(INT) SET work_mem = DEFAULT", ), ( "ALTER FUNCTION alt_func2(int) SET work_mem FROM CURRENT", "ALTER FUNCTION alt_func2(INT) SET work_mem FROM CURRENT", ), ( "ALTER FUNCTION alt_func2(int) SET search_path = pg_catalog, public", "ALTER FUNCTION alt_func2(INT) SET search_path = pg_catalog, public", ), ( "ALTER FUNCTION alt_func2(int) RESET work_mem", "ALTER FUNCTION alt_func2(INT) RESET work_mem", ), ( "ALTER FUNCTION alt_func2(int) RESET ALL", "ALTER FUNCTION alt_func2(INT) RESET ALL", ), ( "ALTER FUNCTION alt_func2(int) IMMUTABLE STRICT PARALLEL SAFE RESTRICT", "ALTER FUNCTION alt_func2(INT) IMMUTABLE STRICT PARALLEL SAFE RESTRICT", ), ( "ALTER FUNCTION alt_variadic(VARIADIC int[]) STABLE", "ALTER FUNCTION alt_variadic(VARIADIC INT[]) STABLE", ), ] { let statement = pg_and_generic().one_statement_parses_to(sql, expected); assert!(matches!( statement, Statement::AlterFunction(AlterFunction { kind: AlterFunctionKind::Function, .. }) )); } assert!(pg() .parse_sql_statements("ALTER AGGREGATE alt_func1(INT) DEPENDS ON EXTENSION ext1") .is_err()); assert!(pg() .parse_sql_statements("ALTER AGGREGATE alt_func1(INT) NO DEPENDS ON EXTENSION ext1") .is_err()); assert!(pg() .parse_sql_statements("ALTER AGGREGATE alt_func1(OUT INT) OWNER TO joe") .is_err()); assert!(pg() .parse_sql_statements("ALTER AGGREGATE alt_func1(INOUT INT) OWNER TO joe") .is_err()); assert!(pg() .parse_sql_statements("ALTER AGGREGATE alt_func1(INT = 1) OWNER TO joe") .is_err()); assert!(pg() .parse_sql_statements("ALTER AGGREGATE alt_func1(INT) IMMUTABLE") .is_err()); } #[test] fn parse_drop_operator_family() { for if_exists in [true, false] { for drop_behavior in [ None, Some(DropBehavior::Cascade), Some(DropBehavior::Restrict), ] { for index_method in &["btree", "hash", "gist", "gin", "spgist", "brin"] { for (names_str, names_vec) in [ ( "float_ops", vec![ObjectName::from(vec![Ident::new("float_ops")])], ), ( "myschema.custom_ops", vec![ObjectName::from(vec![ Ident::new("myschema"), Ident::new("custom_ops"), ])], ), ( "ops1, ops2, schema.ops3", vec![ ObjectName::from(vec![Ident::new("ops1")]), ObjectName::from(vec![Ident::new("ops2")]), ObjectName::from(vec![Ident::new("schema"), Ident::new("ops3")]), ], ), ] { let sql = format!( "DROP OPERATOR FAMILY{} {} USING {}{}", if if_exists { " IF EXISTS" } else { "" }, names_str, index_method, match drop_behavior { Some(behavior) => format!(" {}", behavior), None => String::new(), } ); assert_eq!( pg_and_generic().verified_stmt(&sql), Statement::DropOperatorFamily(DropOperatorFamily { if_exists, names: names_vec, using: Ident::new(*index_method), drop_behavior, }) ); } } } } // Test error: DROP OPERATOR FAMILY with no names let sql = "DROP OPERATOR FAMILY USING btree"; assert!(pg_and_generic().parse_sql_statements(sql).is_err()); // Test error: DROP OPERATOR FAMILY IF EXISTS with no names let sql = "DROP OPERATOR FAMILY IF EXISTS USING btree"; assert!(pg_and_generic().parse_sql_statements(sql).is_err()); } #[test] fn parse_drop_operator_class() { for if_exists in [true, false] { for drop_behavior in [ None, Some(DropBehavior::Cascade), Some(DropBehavior::Restrict), ] { for index_method in &["btree", "hash", "gist", "gin", "spgist", "brin"] { for (names_str, names_vec) in [ ( "widget_ops", vec![ObjectName::from(vec![Ident::new("widget_ops")])], ), ( "myschema.int4_ops", vec![ObjectName::from(vec![ Ident::new("myschema"), Ident::new("int4_ops"), ])], ), ( "ops1, ops2, schema.ops3", vec![ ObjectName::from(vec![Ident::new("ops1")]), ObjectName::from(vec![Ident::new("ops2")]), ObjectName::from(vec![Ident::new("schema"), Ident::new("ops3")]), ], ), ] { let sql = format!( "DROP OPERATOR CLASS{} {} USING {}{}", if if_exists { " IF EXISTS" } else { "" }, names_str, index_method, match drop_behavior { Some(behavior) => format!(" {}", behavior), None => String::new(), } ); assert_eq!( pg_and_generic().verified_stmt(&sql), Statement::DropOperatorClass(DropOperatorClass { if_exists, names: names_vec.clone(), using: Ident::new(*index_method), drop_behavior, }) ); } } } } // Test error: DROP OPERATOR CLASS with no names let sql = "DROP OPERATOR CLASS USING btree"; assert!(pg_and_generic().parse_sql_statements(sql).is_err()); // Test error: DROP OPERATOR CLASS IF EXISTS with no names let sql = "DROP OPERATOR CLASS IF EXISTS USING btree"; assert!(pg_and_generic().parse_sql_statements(sql).is_err()); } #[test] fn parse_create_operator_family() { for index_method in &["btree", "hash", "gist", "gin", "spgist", "brin"] { assert_eq!( pg_and_generic().verified_stmt(&format!( "CREATE OPERATOR FAMILY my_family USING {index_method}" )), Statement::CreateOperatorFamily(CreateOperatorFamily { name: ObjectName::from(vec![Ident::new("my_family")]), using: Ident::new(*index_method), }) ); assert_eq!( pg_and_generic().verified_stmt(&format!( "CREATE OPERATOR FAMILY myschema.test_family USING {index_method}" )), Statement::CreateOperatorFamily(CreateOperatorFamily { name: ObjectName::from(vec![Ident::new("myschema"), Ident::new("test_family")]), using: Ident::new(*index_method), }) ); } } #[test] fn parse_create_operator_class() { // Test all combinations of DEFAULT flag and FAMILY clause with different name qualifications for (is_default, default_clause) in [(false, ""), (true, "DEFAULT ")] { for (has_family, family_clause) in [(false, ""), (true, " FAMILY int4_family")] { for (class_name, expected_name) in [ ("int4_ops", ObjectName::from(vec![Ident::new("int4_ops")])), ( "myschema.test_ops", ObjectName::from(vec![Ident::new("myschema"), Ident::new("test_ops")]), ), ] { let sql = format!( "CREATE OPERATOR CLASS {class_name} {default_clause}FOR TYPE INT4 USING btree{family_clause} AS OPERATOR 1 <" ); match pg_and_generic().verified_stmt(&sql) { Statement::CreateOperatorClass(CreateOperatorClass { name, default, ref for_type, ref using, ref family, ref items, }) => { assert_eq!(name, expected_name); assert_eq!(default, is_default); assert_eq!(for_type, &DataType::Int4(None)); assert_eq!(using, &Ident::new("btree")); assert_eq!( family, &if has_family { Some(ObjectName::from(vec![Ident::new("int4_family")])) } else { None } ); assert_eq!(items.len(), 1); } _ => panic!("Expected CreateOperatorClass statement"), } } } } // Test comprehensive operator class with all fields match pg_and_generic().verified_stmt("CREATE OPERATOR CLASS CAS_btree_ops DEFAULT FOR TYPE CAS USING btree FAMILY CAS_btree_ops AS OPERATOR 1 <, OPERATOR 2 <=, OPERATOR 3 =, OPERATOR 4 >=, OPERATOR 5 >, FUNCTION 1 cas_cmp(CAS, CAS)") { Statement::CreateOperatorClass(CreateOperatorClass { name, default: true, ref for_type, ref using, ref family, ref items, }) => { assert_eq!(name, ObjectName::from(vec![Ident::new("CAS_btree_ops")])); assert_eq!(for_type, &DataType::Custom(ObjectName::from(vec![Ident::new("CAS")]), vec![])); assert_eq!(using, &Ident::new("btree")); assert_eq!(family, &Some(ObjectName::from(vec![Ident::new("CAS_btree_ops")]))); assert_eq!(items.len(), 6); } _ => panic!("Expected CreateOperatorClass statement"), } // Test operator with argument types match pg_and_generic().verified_stmt( "CREATE OPERATOR CLASS test_ops FOR TYPE INT4 USING gist AS OPERATOR 1 < (INT4, INT4)", ) { Statement::CreateOperatorClass(CreateOperatorClass { ref items, .. }) => { assert_eq!(items.len(), 1); match &items[0] { OperatorClassItem::Operator { strategy_number: 1, ref operator_name, op_types: Some(OperatorArgTypes { left: DataType::Int4(None), right: DataType::Int4(None), }), purpose: None, } => { assert_eq!(operator_name, &ObjectName::from(vec![Ident::new("<")])); } _ => panic!("Expected Operator item with arg types"), } } _ => panic!("Expected CreateOperatorClass statement"), } // Test operator FOR SEARCH match pg_and_generic().verified_stmt( "CREATE OPERATOR CLASS test_ops FOR TYPE INT4 USING gist AS OPERATOR 1 < FOR SEARCH", ) { Statement::CreateOperatorClass(CreateOperatorClass { ref items, .. }) => { assert_eq!(items.len(), 1); match &items[0] { OperatorClassItem::Operator { strategy_number: 1, ref operator_name, op_types: None, purpose: Some(OperatorPurpose::ForSearch), } => { assert_eq!(operator_name, &ObjectName::from(vec![Ident::new("<")])); } _ => panic!("Expected Operator item FOR SEARCH"), } } _ => panic!("Expected CreateOperatorClass statement"), } // Test operator FOR ORDER BY match pg().verified_stmt("CREATE OPERATOR CLASS test_ops FOR TYPE INT4 USING gist AS OPERATOR 2 <<-> FOR ORDER BY float_ops") { Statement::CreateOperatorClass(CreateOperatorClass { ref items, .. }) => { assert_eq!(items.len(), 1); match &items[0] { OperatorClassItem::Operator { strategy_number: 2, ref operator_name, op_types: None, purpose: Some(OperatorPurpose::ForOrderBy { ref sort_family }), } => { assert_eq!(operator_name, &ObjectName::from(vec![Ident::new("<<->")])); assert_eq!(sort_family, &ObjectName::from(vec![Ident::new("float_ops")])); } _ => panic!("Expected Operator item FOR ORDER BY"), } } _ => panic!("Expected CreateOperatorClass statement"), } // Test function with operator class arg types match pg_and_generic().verified_stmt("CREATE OPERATOR CLASS test_ops FOR TYPE INT4 USING btree AS FUNCTION 1 (INT4, INT4) btcmp(INT4, INT4)") { Statement::CreateOperatorClass(CreateOperatorClass { ref items, .. }) => { assert_eq!(items.len(), 1); match &items[0] { OperatorClassItem::Function { support_number: 1, op_types: Some(_), ref function_name, ref argument_types, } => { assert_eq!(function_name, &ObjectName::from(vec![Ident::new("btcmp")])); assert_eq!(argument_types.len(), 2); } _ => panic!("Expected Function item with op_types"), } } _ => panic!("Expected CreateOperatorClass statement"), } // Test function with no arguments (empty parentheses normalizes to no parentheses) pg_and_generic().one_statement_parses_to( "CREATE OPERATOR CLASS test_ops FOR TYPE INT4 USING btree AS FUNCTION 1 my_func()", "CREATE OPERATOR CLASS test_ops FOR TYPE INT4 USING btree AS FUNCTION 1 my_func", ); match pg_and_generic().verified_stmt( "CREATE OPERATOR CLASS test_ops FOR TYPE INT4 USING btree AS FUNCTION 1 my_func", ) { Statement::CreateOperatorClass(CreateOperatorClass { ref items, .. }) => { assert_eq!(items.len(), 1); match &items[0] { OperatorClassItem::Function { support_number: 1, op_types: None, ref function_name, ref argument_types, } => { assert_eq!( function_name, &ObjectName::from(vec![Ident::new("my_func")]) ); assert_eq!(argument_types.len(), 0); } _ => panic!("Expected Function item without op_types and no arguments"), } } _ => panic!("Expected CreateOperatorClass statement"), } // Test multiple items including STORAGE match pg_and_generic().verified_stmt("CREATE OPERATOR CLASS gist_ops FOR TYPE geometry USING gist AS OPERATOR 1 <<, FUNCTION 1 gist_consistent(internal, geometry, INT4), STORAGE box") { Statement::CreateOperatorClass(CreateOperatorClass { ref items, .. }) => { assert_eq!(items.len(), 3); // Check operator item match &items[0] { OperatorClassItem::Operator { strategy_number: 1, ref operator_name, .. } => { assert_eq!(operator_name, &ObjectName::from(vec![Ident::new("<<")])); } _ => panic!("Expected Operator item"), } // Check function item match &items[1] { OperatorClassItem::Function { support_number: 1, ref function_name, ref argument_types, .. } => { assert_eq!(function_name, &ObjectName::from(vec![Ident::new("gist_consistent")])); assert_eq!(argument_types.len(), 3); } _ => panic!("Expected Function item"), } // Check storage item match &items[2] { OperatorClassItem::Storage { ref storage_type } => { assert_eq!(storage_type, &DataType::Custom(ObjectName::from(vec![Ident::new("box")]), vec![])); } _ => panic!("Expected Storage item"), } } _ => panic!("Expected CreateOperatorClass statement"), } // Test nested empty parentheses error in function arguments assert!(pg() .parse_sql_statements( "CREATE OPERATOR CLASS test_ops FOR TYPE INT4 USING btree AS FUNCTION 1 cas_cmp(()" ) .is_err()); } #[test] fn parse_identifiers_semicolon_handling() { let statement = "SHOW search_path; SELECT 1"; pg_and_generic().statements_parse_to(statement, statement); let statement = "SHOW search_path; SHOW ALL; SHOW ALL"; pg_and_generic().statements_parse_to(statement, statement); } #[test] fn parse_create_table_partition_of_range() { // RANGE partition with FROM ... TO let sql = "CREATE TABLE measurement_y2006m02 PARTITION OF measurement FOR VALUES FROM ('2006-02-01') TO ('2006-03-01')"; match pg_and_generic().verified_stmt(sql) { Statement::CreateTable(create_table) => { assert_eq!("measurement_y2006m02", create_table.name.to_string()); assert_eq!( Some(ObjectName::from(vec![Ident::new("measurement")])), create_table.partition_of ); match create_table.for_values { Some(ForValues::From { from, to }) => { assert_eq!(1, from.len()); assert_eq!(1, to.len()); match &from[0] { PartitionBoundValue::Expr(Expr::Value(v)) => { assert_eq!("'2006-02-01'", v.to_string()); } _ => panic!("Expected Expr value in from"), } match &to[0] { PartitionBoundValue::Expr(Expr::Value(v)) => { assert_eq!("'2006-03-01'", v.to_string()); } _ => panic!("Expected Expr value in to"), } } _ => panic!("Expected ForValues::From"), } } _ => panic!("Expected CreateTable"), } } #[test] fn parse_create_table_partition_of_range_with_minvalue_maxvalue() { // RANGE partition with MINVALUE/MAXVALUE let sql = "CREATE TABLE orders_old PARTITION OF orders FOR VALUES FROM (MINVALUE) TO ('2020-01-01')"; match pg_and_generic().verified_stmt(sql) { Statement::CreateTable(create_table) => { assert_eq!("orders_old", create_table.name.to_string()); assert_eq!( Some(ObjectName::from(vec![Ident::new("orders")])), create_table.partition_of ); match create_table.for_values { Some(ForValues::From { from, to }) => { assert_eq!(PartitionBoundValue::MinValue, from[0]); match &to[0] { PartitionBoundValue::Expr(Expr::Value(v)) => { assert_eq!("'2020-01-01'", v.to_string()); } _ => panic!("Expected Expr value in to"), } } _ => panic!("Expected ForValues::From"), } } _ => panic!("Expected CreateTable"), } // With MAXVALUE let sql = "CREATE TABLE orders_new PARTITION OF orders FOR VALUES FROM ('2024-01-01') TO (MAXVALUE)"; match pg_and_generic().verified_stmt(sql) { Statement::CreateTable(create_table) => match create_table.for_values { Some(ForValues::From { from, to }) => { match &from[0] { PartitionBoundValue::Expr(Expr::Value(v)) => { assert_eq!("'2024-01-01'", v.to_string()); } _ => panic!("Expected Expr value in from"), } assert_eq!(PartitionBoundValue::MaxValue, to[0]); } _ => panic!("Expected ForValues::From"), }, _ => panic!("Expected CreateTable"), } } #[test] fn parse_create_table_partition_of_list() { // LIST partition let sql = "CREATE TABLE orders_us PARTITION OF orders FOR VALUES IN ('US', 'CA', 'MX')"; match pg_and_generic().verified_stmt(sql) { Statement::CreateTable(create_table) => { assert_eq!("orders_us", create_table.name.to_string()); assert_eq!( Some(ObjectName::from(vec![Ident::new("orders")])), create_table.partition_of ); match create_table.for_values { Some(ForValues::In(values)) => { assert_eq!(3, values.len()); } _ => panic!("Expected ForValues::In"), } } _ => panic!("Expected CreateTable"), } } #[test] fn parse_create_table_partition_of_hash() { // HASH partition let sql = "CREATE TABLE orders_p0 PARTITION OF orders FOR VALUES WITH (MODULUS 4, REMAINDER 0)"; match pg_and_generic().verified_stmt(sql) { Statement::CreateTable(create_table) => { assert_eq!("orders_p0", create_table.name.to_string()); assert_eq!( Some(ObjectName::from(vec![Ident::new("orders")])), create_table.partition_of ); match create_table.for_values { Some(ForValues::With { modulus, remainder }) => { assert_eq!(4, modulus); assert_eq!(0, remainder); } _ => panic!("Expected ForValues::With"), } } _ => panic!("Expected CreateTable"), } } #[test] fn parse_create_table_partition_of_default() { // DEFAULT partition let sql = "CREATE TABLE orders_default PARTITION OF orders DEFAULT"; match pg_and_generic().verified_stmt(sql) { Statement::CreateTable(create_table) => { assert_eq!("orders_default", create_table.name.to_string()); assert_eq!( Some(ObjectName::from(vec![Ident::new("orders")])), create_table.partition_of ); assert_eq!(Some(ForValues::Default), create_table.for_values); } _ => panic!("Expected CreateTable"), } } #[test] fn parse_create_table_partition_of_multicolumn_range() { // Multi-column RANGE partition let sql = "CREATE TABLE sales_2023_q1 PARTITION OF sales FOR VALUES FROM ('2023-01-01', 1) TO ('2023-04-01', 1)"; match pg_and_generic().verified_stmt(sql) { Statement::CreateTable(create_table) => { assert_eq!("sales_2023_q1", create_table.name.to_string()); match create_table.for_values { Some(ForValues::From { from, to }) => { assert_eq!(2, from.len()); assert_eq!(2, to.len()); } _ => panic!("Expected ForValues::From"), } } _ => panic!("Expected CreateTable"), } } #[test] fn parse_create_table_partition_of_with_constraint() { // With table constraint (not column constraint which has different syntax in PARTITION OF) let sql = "CREATE TABLE orders_2023 PARTITION OF orders (\ CONSTRAINT check_date CHECK (order_date >= '2023-01-01')\ ) FOR VALUES FROM ('2023-01-01') TO ('2024-01-01')"; match pg_and_generic().verified_stmt(sql) { Statement::CreateTable(create_table) => { assert_eq!("orders_2023", create_table.name.to_string()); assert_eq!( Some(ObjectName::from(vec![Ident::new("orders")])), create_table.partition_of ); // Check that table constraint was parsed assert_eq!(1, create_table.constraints.len()); match create_table.for_values { Some(ForValues::From { .. }) => {} _ => panic!("Expected ForValues::From"), } } _ => panic!("Expected CreateTable"), } } #[test] fn parse_create_table_partition_of_errors() { let sql = "CREATE TABLE p PARTITION OF parent"; let result = pg_and_generic().parse_sql_statements(sql); assert!(result.is_err()); let err = result.unwrap_err().to_string(); assert!( err.contains("FOR VALUES or DEFAULT"), "Expected error about FOR VALUES, got: {err}" ); let sql = "CREATE TABLE p PARTITION OF parent WITH (fillfactor = 70)"; let result = pg_and_generic().parse_sql_statements(sql); assert!(result.is_err()); let err = result.unwrap_err().to_string(); assert!( err.contains("FOR VALUES or DEFAULT"), "Expected error about FOR VALUES, got: {err}" ); let sql = "CREATE TABLE p PARTITION OF parent FOR VALUES RANGE (1, 10)"; let result = pg_and_generic().parse_sql_statements(sql); assert!(result.is_err()); let err = result.unwrap_err().to_string(); assert!( err.contains("IN, FROM, or WITH"), "Expected error about invalid keyword after FOR VALUES, got: {err}" ); let sql = "CREATE TABLE p PARTITION OF parent FOR VALUES FROM (1)"; let result = pg_and_generic().parse_sql_statements(sql); assert!(result.is_err()); let err = result.unwrap_err().to_string(); assert!( err.contains("TO"), "Expected error about missing TO clause, got: {err}" ); let sql = "CREATE TABLE p PARTITION OF parent FOR VALUES IN ()"; let result = pg_and_generic().parse_sql_statements(sql); assert!(result.is_err()); let err = result.unwrap_err().to_string(); assert!( err.contains("at least one value"), "Expected error about empty value list in IN clause, got: {err}" ); let sql = "CREATE TABLE p PARTITION OF parent FOR VALUES FROM () TO (10)"; let result = pg_and_generic().parse_sql_statements(sql); assert!(result.is_err()); let err = result.unwrap_err().to_string(); assert!( err.contains("at least one value"), "Expected error about empty FROM list, got: {err}" ); let sql = "CREATE TABLE p PARTITION OF parent FOR VALUES FROM (1) TO ()"; let result = pg_and_generic().parse_sql_statements(sql); assert!(result.is_err()); let err = result.unwrap_err().to_string(); assert!( err.contains("at least one value"), "Expected error about empty TO list, got: {err}" ); } #[test] fn parse_pg_analyze() { // Bare ANALYZE pg_and_generic().verified_stmt("ANALYZE"); // ANALYZE with table name pg_and_generic().verified_stmt("ANALYZE t"); // ANALYZE with column specification pg_and_generic().verified_stmt("ANALYZE t (col1, col2)"); // Verify AST for column specification let stmt = pg().verified_stmt("ANALYZE t (col1, col2)"); match &stmt { Statement::Analyze(analyze) => { assert_eq!(analyze.table_name.as_ref().unwrap().to_string(), "t"); assert_eq!(analyze.columns.len(), 2); assert_eq!(analyze.columns[0].to_string(), "col1"); assert_eq!(analyze.columns[1].to_string(), "col2"); assert!(!analyze.for_columns); } _ => panic!("Expected Analyze, got: {stmt:?}"), } } #[test] fn parse_lock_table() { pg_and_generic().one_statement_parses_to( "LOCK public.widgets IN EXCLUSIVE MODE", "LOCK TABLE public.widgets IN EXCLUSIVE MODE", ); pg_and_generic().one_statement_parses_to( "LOCK TABLE public.widgets NOWAIT", "LOCK TABLE public.widgets NOWAIT", ); let stmt = pg_and_generic().verified_stmt( "LOCK TABLE ONLY public.widgets, analytics.events * IN SHARE ROW EXCLUSIVE MODE NOWAIT", ); match stmt { Statement::Lock(lock) => { assert_eq!(lock.tables.len(), 2); assert_eq!(lock.tables[0].name.to_string(), "public.widgets"); assert!(lock.tables[0].only); assert!(!lock.tables[0].has_asterisk); assert_eq!(lock.tables[1].name.to_string(), "analytics.events"); assert!(!lock.tables[1].only); assert!(lock.tables[1].has_asterisk); assert_eq!(lock.lock_mode, Some(LockTableMode::ShareRowExclusive)); assert!(lock.nowait); } _ => panic!("Expected Lock, got: {stmt:?}"), } let lock_modes = [ ("ACCESS SHARE", LockTableMode::AccessShare), ("ROW SHARE", LockTableMode::RowShare), ("ROW EXCLUSIVE", LockTableMode::RowExclusive), ( "SHARE UPDATE EXCLUSIVE", LockTableMode::ShareUpdateExclusive, ), ("SHARE", LockTableMode::Share), ("SHARE ROW EXCLUSIVE", LockTableMode::ShareRowExclusive), ("EXCLUSIVE", LockTableMode::Exclusive), ("ACCESS EXCLUSIVE", LockTableMode::AccessExclusive), ]; for (mode_sql, expected_mode) in lock_modes { let stmt = pg_and_generic() .verified_stmt(&format!("LOCK TABLE public.widgets IN {mode_sql} MODE")); match stmt { Statement::Lock(lock) => { assert_eq!(lock.tables.len(), 1); assert_eq!(lock.tables[0].name.to_string(), "public.widgets"); assert!(!lock.tables[0].only); assert!(!lock.tables[0].has_asterisk); assert_eq!(lock.lock_mode, Some(expected_mode)); assert!(!lock.nowait); } _ => panic!("Expected Lock, got: {stmt:?}"), } } } apache-datafusion-sqlparser-rs-0.62.0/tests/sqlparser_redshift.rs000066400000000000000000000426001517524037000252310ustar00rootroot00000000000000// 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. #[macro_use] mod test_utils; use sqlparser::tokenizer::Span; use test_utils::*; use sqlparser::ast::*; use sqlparser::dialect::GenericDialect; use sqlparser::dialect::RedshiftSqlDialect; #[test] fn test_square_brackets_over_db_schema_table_name() { let select = redshift().verified_only_select("SELECT [col1] FROM [test_schema].[test_table]"); assert_eq!( select.projection[0], SelectItem::UnnamedExpr(Expr::Identifier(Ident { value: "col1".to_string(), quote_style: Some('['), span: Span::empty(), })), ); 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(), } ])), joins: vec![], } ); } #[test] fn brackets_over_db_schema_table_name_with_whites_paces() { match redshift().parse_sql_statements("SELECT [ col1 ] FROM [ test_schema].[ test_table]") { Ok(statements) => { assert_eq!(statements.len(), 1); } _ => unreachable!(), } } #[test] fn test_double_quotes_over_db_schema_table_name() { let select = redshift().verified_only_select("SELECT \"col1\" FROM \"test_schema\".\"test_table\""); assert_eq!( select.projection[0], SelectItem::UnnamedExpr(Expr::Identifier(Ident { value: "col1".to_string(), quote_style: Some('"'), span: Span::empty(), })), ); 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(), } ])), joins: vec![], } ); } #[test] fn parse_delimited_identifiers() { // check that quoted identifiers in any position remain quoted after serialization let select = redshift().verified_only_select( r#"SELECT "alias"."bar baz", "myfun"(), "simple id" AS "column alias" FROM "a table" AS "alias""#, ); // check FROM match only(select.from).relation { TableFactor::Table { name, alias, args, with_hints, version, .. } => { assert_eq!( ObjectName::from(vec![Ident::with_quote('"', "a table")]), name ); assert_eq!(Ident::with_quote('"', "alias"), alias.unwrap().name); assert!(args.is_none()); assert!(with_hints.is_empty()); assert!(version.is_none()); } _ => panic!("Expecting TableFactor::Table"), } // check SELECT assert_eq!(3, select.projection.len()); assert_eq!( &Expr::CompoundIdentifier(vec![ Ident::with_quote('"', "alias"), Ident::with_quote('"', "bar baz"), ]), expr_from_projection(&select.projection[0]), ); assert_eq!( &Expr::Function(Function { name: ObjectName::from(vec![Ident::with_quote('"', "myfun")]), uses_odbc_syntax: false, parameters: FunctionArguments::None, args: FunctionArguments::List(FunctionArgumentList { duplicate_treatment: None, args: vec![], clauses: vec![], }), null_treatment: None, filter: None, over: None, within_group: vec![], }), expr_from_projection(&select.projection[1]), ); match &select.projection[2] { SelectItem::ExprWithAlias { expr, alias } => { assert_eq!(&Expr::Identifier(Ident::with_quote('"', "simple id")), expr); assert_eq!(&Ident::with_quote('"', "column alias"), alias); } _ => panic!("Expected ExprWithAlias"), } 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"#); } fn redshift() -> TestedDialects { TestedDialects::new(vec![Box::new(RedshiftSqlDialect {})]) } fn redshift_and_generic() -> TestedDialects { TestedDialects::new(vec![ Box::new(RedshiftSqlDialect {}), Box::new(GenericDialect {}), ]) } #[test] fn test_sharp() { let sql = "SELECT #_of_values"; let select = redshift().verified_only_select(sql); assert_eq!( SelectItem::UnnamedExpr(Expr::Identifier(Ident::new("#_of_values"))), select.projection[0] ); } #[test] 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 🚀"); } #[test] fn parse_vacuum() { let stmt = redshift().verified_stmt("VACUUM FULL"); match stmt { Statement::Vacuum(v) => { assert!(v.full); assert_eq!(v.table_name, None); } _ => unreachable!(), } let stmt = redshift().verified_stmt("VACUUM tbl"); match stmt { Statement::Vacuum(v) => { assert_eq!( v.table_name, Some(ObjectName::from(vec![Ident::new("tbl"),])) ); } _ => unreachable!(), } let stmt = redshift().verified_stmt( "VACUUM FULL SORT ONLY DELETE ONLY REINDEX RECLUSTER db1.sc1.tbl1 TO 20 PERCENT BOOST", ); match stmt { Statement::Vacuum(v) => { assert!(v.full); assert!(v.sort_only); assert!(v.delete_only); assert!(v.reindex); assert!(v.recluster); assert_eq!( v.table_name, Some(ObjectName::from(vec![ Ident::new("db1"), Ident::new("sc1"), Ident::new("tbl1"), ])) ); assert_eq!(v.threshold, Some(number("20").with_empty_span())); assert!(v.boost); } _ => unreachable!(), } } #[test] fn test_create_table_diststyle_distkey() { redshift().verified_stmt( "CREATE TEMPORARY TABLE tmp_sbk_summary_pp DISTSTYLE KEY DISTKEY(bet_id) AS SELECT 1 AS bet_id", ); } #[test] fn test_create_table_diststyle() { redshift().verified_stmt("CREATE TABLE t1 (c1 INT) DISTSTYLE AUTO"); redshift().verified_stmt("CREATE TABLE t1 (c1 INT) DISTSTYLE EVEN"); redshift().verified_stmt("CREATE TABLE t1 (c1 INT) DISTSTYLE KEY DISTKEY(c1)"); redshift().verified_stmt("CREATE TABLE t1 (c1 INT) DISTSTYLE ALL"); } #[test] fn test_copy_credentials() { redshift().verified_stmt( "COPY t1 FROM 's3://bucket/file.csv' CREDENTIALS 'aws_access_key_id=AK;aws_secret_access_key=SK' CSV", ); } #[test] fn test_create_table_sortkey() { redshift().verified_stmt("CREATE TABLE t1 (c1 INT, c2 INT, c3 TIMESTAMP) SORTKEY(c3)"); redshift().verified_stmt("CREATE TABLE t1 (c1 INT, c2 INT) SORTKEY(c1, c2)"); } #[test] fn test_create_table_distkey_sortkey_with_ctas() { redshift().verified_stmt( "CREATE TABLE t1 DISTKEY(1) SORTKEY(1, 3) AS SELECT eventid, venueid, dateid, eventname FROM event", ); } #[test] fn test_create_table_diststyle_distkey_sortkey() { redshift().verified_stmt( "CREATE TABLE t1 (c1 INT, c2 INT) DISTSTYLE KEY DISTKEY(c1) SORTKEY(c1, c2)", ); } #[test] fn test_alter_table_alter_sortkey() { redshift().verified_stmt("ALTER TABLE users ALTER SORTKEY(created_at)"); redshift().verified_stmt("ALTER TABLE users ALTER SORTKEY(c1, c2)"); } #[test] fn test_create_table_backup() { redshift().verified_stmt("CREATE TABLE public.users (id INT, name VARCHAR(255)) BACKUP YES"); redshift().verified_stmt("CREATE TABLE staging.events (event_id INT) BACKUP NO"); redshift().verified_stmt( "CREATE TABLE public.users_backup_test BACKUP YES DISTSTYLE AUTO AS SELECT id, name, email FROM public.users", ); } #[test] fn test_null_treatment_inside_and_outside_window_function() { redshift().verified_stmt("SELECT FIRST_VALUE(1 IGNORE NULLS) OVER () FROM (SELECT 1) t"); redshift().verified_stmt("SELECT FIRST_VALUE(1) IGNORE NULLS OVER () FROM (SELECT 1) t"); } #[test] fn test_partiql_from_alias_with_at_index() { let dialects = all_dialects_where(|d| d.supports_partiql()); dialects.verified_stmt("SELECT * FROM lineitem AS l (a, b, c) AT idx"); let sql = "SELECT index, val FROM (SELECT array('AAA', 'BBB') AS val) AS b, b.val AS val AT index"; let select = dialects.verified_only_select(sql); match &select.from[1].relation { TableFactor::Table { name, alias, .. } => { assert_eq!( name, &ObjectName::from(vec![Ident::new("b"), Ident::new("val")]) ); assert_eq!(alias.as_ref().map(|a| &a.name), Some(&Ident::new("val"))); assert_eq!( alias.as_ref().and_then(|a| a.at.as_ref()), Some(&Ident::new("index")) ); } _ => panic!("expected table factor"), } } apache-datafusion-sqlparser-rs-0.62.0/tests/sqlparser_regression.rs000066400000000000000000000032201517524037000255740ustar00rootroot00000000000000// 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. #![warn(clippy::all)] use sqlparser::dialect::GenericDialect; use sqlparser::parser::Parser; macro_rules! tpch_tests { ($($name:ident: $value:expr,)*) => { const QUERIES: &[&str] = &[ $(include_str!(concat!("queries/tpch/", $value, ".sql"))),* ]; $( #[test] fn $name() { let dialect = GenericDialect {}; let res = Parser::parse_sql(&dialect, QUERIES[$value -1]); assert!(res.is_ok()); } )* } } tpch_tests! { tpch_1: 1, tpch_2: 2, tpch_3: 3, tpch_4: 4, tpch_5: 5, tpch_6: 6, tpch_7: 7, tpch_8: 8, tpch_9: 9, tpch_10: 10, tpch_11: 11, tpch_12: 12, tpch_13: 13, tpch_14: 14, tpch_15: 15, tpch_16: 16, tpch_17: 17, tpch_18: 18, tpch_19: 19, tpch_20: 20, tpch_21: 21, tpch_22: 22, } apache-datafusion-sqlparser-rs-0.62.0/tests/sqlparser_snowflake.rs000066400000000000000000005440241517524037000254210ustar00rootroot00000000000000// 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. #![warn(clippy::all)] //! Test SQL syntax specific to Snowflake. The parser based on the //! generic dialect is also tested (on the inputs it can handle). use sqlparser::ast::helpers::key_value_options::{KeyValueOption, KeyValueOptionKind}; use sqlparser::ast::helpers::stmt_data_loading::{StageLoadSelectItem, StageLoadSelectItemKind}; use sqlparser::ast::*; use sqlparser::dialect::{Dialect, GenericDialect, SnowflakeDialect}; use sqlparser::parser::{ParserError, ParserOptions}; use sqlparser::tokenizer::*; use test_utils::*; #[macro_use] mod test_utils; #[cfg(test)] use pretty_assertions::assert_eq; #[test] fn test_snowflake_create_table() { let sql = "CREATE TABLE _my_$table (am00unt number)"; match snowflake_and_generic().verified_stmt(sql) { Statement::CreateTable(CreateTable { name, .. }) => { assert_eq!("_my_$table", name.to_string()); } _ => unreachable!(), } } #[test] fn parse_sf_create_secure_view_and_materialized_view() { for sql in [ "CREATE SECURE VIEW v AS SELECT 1", "CREATE SECURE MATERIALIZED VIEW v AS SELECT 1", "CREATE OR REPLACE SECURE VIEW v AS SELECT 1", "CREATE OR REPLACE SECURE MATERIALIZED VIEW v AS SELECT 1", ] { match snowflake().verified_stmt(sql) { Statement::CreateView(CreateView { secure, materialized, .. }) => { assert!(secure); if sql.contains("MATERIALIZED") { assert!(materialized); } else { assert!(!materialized); } } _ => unreachable!(), } assert_eq!(snowflake().verified_stmt(sql).to_string(), sql); } } #[test] fn test_snowflake_create_or_replace_table() { let sql = "CREATE OR REPLACE TABLE my_table (a number)"; match snowflake().verified_stmt(sql) { Statement::CreateTable(CreateTable { name, or_replace, .. }) => { assert_eq!("my_table", name.to_string()); assert!(or_replace); } _ => unreachable!(), } } #[test] fn test_snowflake_create_or_replace_table_copy_grants() { let sql = "CREATE OR REPLACE TABLE my_table (a number) COPY GRANTS"; match snowflake().verified_stmt(sql) { Statement::CreateTable(CreateTable { name, or_replace, copy_grants, .. }) => { assert_eq!("my_table", name.to_string()); assert!(or_replace); assert!(copy_grants); } _ => unreachable!(), } } #[test] fn test_snowflake_create_or_replace_table_copy_grants_at_end() { let sql = "CREATE OR REPLACE TABLE my_table COPY GRANTS (a number) "; let parsed = "CREATE OR REPLACE TABLE my_table (a number) COPY GRANTS"; match snowflake().one_statement_parses_to(sql, parsed) { Statement::CreateTable(CreateTable { name, or_replace, copy_grants, .. }) => { assert_eq!("my_table", name.to_string()); assert!(or_replace); assert!(copy_grants); } _ => unreachable!(), } } #[test] fn test_snowflake_create_or_replace_table_copy_grants_cta() { let sql = "CREATE OR REPLACE TABLE my_table COPY GRANTS AS SELECT 1 AS a"; match snowflake().verified_stmt(sql) { Statement::CreateTable(CreateTable { name, or_replace, copy_grants, .. }) => { assert_eq!("my_table", name.to_string()); assert!(or_replace); assert!(copy_grants); } _ => unreachable!(), } } #[test] fn test_snowflake_create_table_enable_schema_evolution() { let sql = "CREATE TABLE my_table (a number) ENABLE_SCHEMA_EVOLUTION=TRUE"; match snowflake().verified_stmt(sql) { Statement::CreateTable(CreateTable { name, enable_schema_evolution, .. }) => { assert_eq!("my_table", name.to_string()); assert_eq!(Some(true), enable_schema_evolution); } _ => unreachable!(), } } #[test] fn test_snowflake_create_table_change_tracking() { let sql = "CREATE TABLE my_table (a number) CHANGE_TRACKING=TRUE"; match snowflake().verified_stmt(sql) { Statement::CreateTable(CreateTable { name, change_tracking, .. }) => { assert_eq!("my_table", name.to_string()); assert_eq!(Some(true), change_tracking); } _ => unreachable!(), } } #[test] fn test_snowflake_create_table_data_retention_time_in_days() { let sql = "CREATE TABLE my_table (a number) DATA_RETENTION_TIME_IN_DAYS=5"; match snowflake().verified_stmt(sql) { Statement::CreateTable(CreateTable { name, data_retention_time_in_days, .. }) => { assert_eq!("my_table", name.to_string()); assert_eq!(Some(5), data_retention_time_in_days); } _ => unreachable!(), } } #[test] fn test_snowflake_create_table_max_data_extension_time_in_days() { let sql = "CREATE TABLE my_table (a number) MAX_DATA_EXTENSION_TIME_IN_DAYS=5"; match snowflake().verified_stmt(sql) { Statement::CreateTable(CreateTable { name, max_data_extension_time_in_days, .. }) => { assert_eq!("my_table", name.to_string()); assert_eq!(Some(5), max_data_extension_time_in_days); } _ => unreachable!(), } } #[test] fn test_snowflake_create_table_with_aggregation_policy() { match snowflake() .verified_stmt("CREATE TABLE my_table (a number) WITH AGGREGATION POLICY policy_name") { Statement::CreateTable(CreateTable { name, with_aggregation_policy, .. }) => { assert_eq!("my_table", name.to_string()); assert_eq!( Some("policy_name".to_string()), with_aggregation_policy.map(|name| name.to_string()) ); } _ => unreachable!(), } match snowflake() .parse_sql_statements("CREATE TABLE my_table (a number) AGGREGATION POLICY policy_name") .unwrap() .pop() .unwrap() { Statement::CreateTable(CreateTable { name, with_aggregation_policy, .. }) => { assert_eq!("my_table", name.to_string()); assert_eq!( Some("policy_name".to_string()), with_aggregation_policy.map(|name| name.to_string()) ); } _ => unreachable!(), } } #[test] fn test_snowflake_create_table_with_row_access_policy() { match snowflake().verified_stmt( "CREATE TABLE my_table (a number, b number) WITH ROW ACCESS POLICY policy_name ON (a)", ) { Statement::CreateTable(CreateTable { name, with_row_access_policy, .. }) => { assert_eq!("my_table", name.to_string()); assert_eq!( Some("WITH ROW ACCESS POLICY policy_name ON (a)".to_string()), with_row_access_policy.map(|policy| policy.to_string()) ); } _ => unreachable!(), } match snowflake() .parse_sql_statements( "CREATE TABLE my_table (a number, b number) ROW ACCESS POLICY policy_name ON (a)", ) .unwrap() .pop() .unwrap() { Statement::CreateTable(CreateTable { name, with_row_access_policy, .. }) => { assert_eq!("my_table", name.to_string()); assert_eq!( Some("WITH ROW ACCESS POLICY policy_name ON (a)".to_string()), with_row_access_policy.map(|policy| policy.to_string()) ); } _ => unreachable!(), } } #[test] fn test_snowflake_create_table_with_storage_lifecycle_policy() { // WITH keyword match snowflake().verified_stmt( "CREATE TABLE IF NOT EXISTS my_table (a NUMBER(38, 0), b VARIANT) WITH STORAGE LIFECYCLE POLICY dba.global_settings.my_policy ON (a)", ) { Statement::CreateTable(CreateTable { name, with_storage_lifecycle_policy, .. }) => { assert_eq!("my_table", name.to_string()); let policy = with_storage_lifecycle_policy.unwrap(); assert_eq!("dba.global_settings.my_policy", policy.policy.to_string()); assert_eq!(vec![Ident::new("a")], policy.on); } _ => unreachable!(), } // Without WITH keyword — canonicalizes to WITH form snowflake().one_statement_parses_to( "CREATE TABLE my_table (a NUMBER(38, 0)) STORAGE LIFECYCLE POLICY my_policy ON (a, b)", "CREATE TABLE my_table (a NUMBER(38, 0)) WITH STORAGE LIFECYCLE POLICY my_policy ON (a, b)", ); } #[test] fn test_snowflake_create_table_with_tag() { match snowflake() .verified_stmt("CREATE TABLE my_table (a number) WITH TAG (A='TAG A', B='TAG B')") { Statement::CreateTable(CreateTable { name, with_tags, .. }) => { assert_eq!("my_table", name.to_string()); assert_eq!( Some(vec![ Tag::new(ObjectName::from(vec![Ident::new("A")]), "TAG A".to_string()), Tag::new(ObjectName::from(vec![Ident::new("B")]), "TAG B".to_string()) ]), with_tags ); } _ => unreachable!(), } match snowflake() .parse_sql_statements("CREATE TABLE my_table (a number) TAG (A='TAG A', B='TAG B')") .unwrap() .pop() .unwrap() { Statement::CreateTable(CreateTable { name, with_tags, .. }) => { assert_eq!("my_table", name.to_string()); assert_eq!( Some(vec![ Tag::new(ObjectName::from(vec![Ident::new("A")]), "TAG A".to_string()), Tag::new(ObjectName::from(vec![Ident::new("B")]), "TAG B".to_string()) ]), with_tags ); } _ => unreachable!(), } } #[test] fn test_snowflake_create_table_default_ddl_collation() { let sql = "CREATE TABLE my_table (a number) DEFAULT_DDL_COLLATION='de'"; match snowflake().verified_stmt(sql) { Statement::CreateTable(CreateTable { name, default_ddl_collation, .. }) => { assert_eq!("my_table", name.to_string()); assert_eq!(Some("de".to_string()), default_ddl_collation); } _ => unreachable!(), } } #[test] fn test_snowflake_create_transient_table() { let sql = "CREATE TRANSIENT TABLE CUSTOMER (id INT, name VARCHAR(255))"; match snowflake_and_generic().verified_stmt(sql) { Statement::CreateTable(CreateTable { name, transient, .. }) => { assert_eq!("CUSTOMER", name.to_string()); assert!(transient) } _ => unreachable!(), } } #[test] fn test_snowflake_create_table_column_comment() { let sql = "CREATE TABLE my_table (a STRING COMMENT 'some comment')"; match snowflake().verified_stmt(sql) { Statement::CreateTable(CreateTable { name, columns, .. }) => { assert_eq!("my_table", name.to_string()); assert_eq!( vec![ColumnDef { name: "a".into(), data_type: DataType::String(None), options: vec![ColumnOptionDef { name: None, option: ColumnOption::Comment("some comment".to_string()) }], }], columns ) } _ => unreachable!(), } } #[test] fn test_snowflake_create_table_on_commit() { snowflake().verified_stmt( r#"CREATE LOCAL TEMPORARY TABLE "AAA"."foo" ("bar" INTEGER) ON COMMIT PRESERVE ROWS"#, ); snowflake().verified_stmt(r#"CREATE TABLE "AAA"."foo" ("bar" INTEGER) ON COMMIT DELETE ROWS"#); snowflake().verified_stmt(r#"CREATE TABLE "AAA"."foo" ("bar" INTEGER) ON COMMIT DROP"#); } #[test] fn test_snowflake_create_local_table() { match snowflake().verified_stmt("CREATE TABLE my_table (a INT)") { Statement::CreateTable(CreateTable { name, global, .. }) => { assert_eq!("my_table", name.to_string()); assert!(global.is_none()) } _ => unreachable!(), } match snowflake().verified_stmt("CREATE LOCAL TABLE my_table (a INT)") { Statement::CreateTable(CreateTable { name, global, .. }) => { assert_eq!("my_table", name.to_string()); assert_eq!(Some(false), global) } _ => unreachable!(), } } #[test] fn test_snowflake_create_global_table() { match snowflake().verified_stmt("CREATE GLOBAL TABLE my_table (a INT)") { Statement::CreateTable(CreateTable { name, global, .. }) => { assert_eq!("my_table", name.to_string()); assert_eq!(Some(true), global) } _ => unreachable!(), } } #[test] fn test_snowflake_create_invalid_local_global_table() { assert_eq!( snowflake().parse_sql_statements("CREATE LOCAL GLOBAL TABLE my_table (a INT)"), Err(ParserError::ParserError( "Expected: an SQL statement, found: LOCAL".to_string() )) ); assert_eq!( snowflake().parse_sql_statements("CREATE GLOBAL LOCAL TABLE my_table (a INT)"), Err(ParserError::ParserError( "Expected: an SQL statement, found: GLOBAL".to_string() )) ); } #[test] fn test_snowflake_create_invalid_temporal_table() { assert_eq!( snowflake().parse_sql_statements("CREATE TEMP TEMPORARY TABLE my_table (a INT)"), Err(ParserError::ParserError( "Expected: an object type after CREATE, found: TEMPORARY".to_string() )) ); assert_eq!( snowflake().parse_sql_statements("CREATE TEMP VOLATILE TABLE my_table (a INT)"), Err(ParserError::ParserError( "Expected: an object type after CREATE, found: VOLATILE".to_string() )) ); assert_eq!( snowflake().parse_sql_statements("CREATE TEMP TRANSIENT TABLE my_table (a INT)"), Err(ParserError::ParserError( "Expected: an object type after CREATE, found: TRANSIENT".to_string() )) ); } #[test] fn test_snowflake_create_table_if_not_exists() { match snowflake().verified_stmt("CREATE TABLE IF NOT EXISTS my_table (a INT)") { Statement::CreateTable(CreateTable { name, if_not_exists, .. }) => { assert_eq!("my_table", name.to_string()); assert!(if_not_exists) } _ => unreachable!(), } for (sql, parse_to) in [ ( r#"CREATE TABLE IF NOT EXISTS "A"."B"."C" (v VARIANT)"#, r#"CREATE TABLE IF NOT EXISTS "A"."B"."C" (v VARIANT)"#, ), ( r#"CREATE TABLE "A"."B"."C" IF NOT EXISTS (v VARIANT)"#, r#"CREATE TABLE IF NOT EXISTS "A"."B"."C" (v VARIANT)"#, ), ( r#"CREATE TRANSIENT TABLE IF NOT EXISTS "A"."B"."C" (v VARIANT)"#, r#"CREATE TRANSIENT TABLE IF NOT EXISTS "A"."B"."C" (v VARIANT)"#, ), ( r#"CREATE TRANSIENT TABLE "A"."B"."C" IF NOT EXISTS (v VARIANT)"#, r#"CREATE TRANSIENT TABLE IF NOT EXISTS "A"."B"."C" (v VARIANT)"#, ), ] { snowflake().one_statement_parses_to(sql, parse_to); } } #[test] fn test_snowflake_create_table_cluster_by() { match snowflake().verified_stmt("CREATE TABLE my_table (a INT) CLUSTER BY (a, b, my_func(c))") { Statement::CreateTable(CreateTable { name, cluster_by, .. }) => { assert_eq!("my_table", name.to_string()); assert_eq!( Some(WrappedCollection::Parentheses(vec![ Expr::Identifier(Ident::new("a")), Expr::Identifier(Ident::new("b")), Expr::Function(Function { name: ObjectName::from(vec![Ident::new("my_func")]), uses_odbc_syntax: false, parameters: FunctionArguments::None, args: FunctionArguments::List(FunctionArgumentList { args: vec![FunctionArg::Unnamed(FunctionArgExpr::Expr( Expr::Identifier(Ident::new("c")) ))], duplicate_treatment: None, clauses: vec![], }), filter: None, null_treatment: None, over: None, within_group: vec![], }), ])), cluster_by ) } _ => unreachable!(), } } #[test] fn test_snowflake_create_table_comment() { match snowflake().verified_stmt("CREATE TABLE my_table (a INT) COMMENT = 'some comment'") { Statement::CreateTable(CreateTable { name, table_options, .. }) => { assert_eq!("my_table", name.to_string()); let plain_options = match table_options { CreateTableOptions::Plain(options) => options, _ => unreachable!(), }; let comment = match plain_options.first().unwrap() { SqlOption::Comment(CommentDef::WithEq(c)) | SqlOption::Comment(CommentDef::WithoutEq(c)) => c, _ => unreachable!(), }; assert_eq!("some comment", comment); } _ => unreachable!(), } } #[test] fn test_snowflake_single_line_tokenize() { let sql = "CREATE TABLE# this is a comment \ntable_1"; let dialect = SnowflakeDialect {}; let tokens = Tokenizer::new(&dialect, sql).tokenize().unwrap(); let expected = vec![ Token::make_keyword("CREATE"), Token::Whitespace(Whitespace::Space), Token::make_keyword("TABLE"), Token::Whitespace(Whitespace::SingleLineComment { prefix: "#".to_string(), comment: " this is a comment \n".to_string(), }), Token::make_word("table_1", None), ]; assert_eq!(expected, tokens); let sql = "CREATE TABLE // this is a comment \ntable_1"; let tokens = Tokenizer::new(&dialect, sql).tokenize().unwrap(); let expected = vec![ Token::make_keyword("CREATE"), Token::Whitespace(Whitespace::Space), Token::make_keyword("TABLE"), Token::Whitespace(Whitespace::Space), Token::Whitespace(Whitespace::SingleLineComment { prefix: "//".to_string(), comment: " this is a comment \n".to_string(), }), Token::make_word("table_1", None), ]; assert_eq!(expected, tokens); } #[test] fn test_snowflake_create_table_with_autoincrement_columns() { let sql = concat!( "CREATE TABLE my_table (", "a INT AUTOINCREMENT ORDER, ", "b INT AUTOINCREMENT(100, 1) NOORDER, ", "c INT IDENTITY, ", "d INT IDENTITY START 100 INCREMENT 1 ORDER", ")" ); // it is a snowflake specific options (AUTOINCREMENT/IDENTITY) match snowflake().verified_stmt(sql) { Statement::CreateTable(CreateTable { columns, .. }) => { assert_eq!( columns, vec![ ColumnDef { name: "a".into(), data_type: DataType::Int(None), options: vec![ColumnOptionDef { name: None, option: ColumnOption::Identity(IdentityPropertyKind::Autoincrement( IdentityProperty { parameters: None, order: Some(IdentityPropertyOrder::Order), } )) }] }, ColumnDef { name: "b".into(), data_type: DataType::Int(None), options: vec![ColumnOptionDef { name: None, option: ColumnOption::Identity(IdentityPropertyKind::Autoincrement( IdentityProperty { parameters: Some(IdentityPropertyFormatKind::FunctionCall( IdentityParameters { seed: Expr::value(number("100")), increment: Expr::value(number("1")), } )), order: Some(IdentityPropertyOrder::NoOrder), } )) }] }, ColumnDef { name: "c".into(), data_type: DataType::Int(None), options: vec![ColumnOptionDef { name: None, option: ColumnOption::Identity(IdentityPropertyKind::Identity( IdentityProperty { parameters: None, order: None, } )) }] }, ColumnDef { name: "d".into(), data_type: DataType::Int(None), options: vec![ColumnOptionDef { name: None, option: ColumnOption::Identity(IdentityPropertyKind::Identity( IdentityProperty { parameters: Some( IdentityPropertyFormatKind::StartAndIncrement( IdentityParameters { seed: Expr::Value( (number("100")).with_empty_span() ), increment: Expr::Value( (number("1")).with_empty_span() ), } ) ), order: Some(IdentityPropertyOrder::Order), } )) }] }, ] ); } _ => unreachable!(), } } #[test] fn test_snowflake_create_table_with_collated_column() { match snowflake_and_generic().verified_stmt("CREATE TABLE my_table (a TEXT COLLATE 'de_DE')") { Statement::CreateTable(CreateTable { columns, .. }) => { assert_eq!( columns, vec![ColumnDef { name: "a".into(), data_type: DataType::Text, options: vec![ColumnOptionDef { name: None, option: ColumnOption::Collation(ObjectName::from(vec![Ident::with_quote( '\'', "de_DE" )])), }] },] ); } _ => unreachable!(), } } #[test] fn test_snowflake_create_table_with_columns_masking_policy() { for (sql, with, using_columns) in [ ( "CREATE TABLE my_table (a INT WITH MASKING POLICY p)", true, None, ), ( "CREATE TABLE my_table (a INT MASKING POLICY p)", false, None, ), ( "CREATE TABLE my_table (a INT WITH MASKING POLICY p USING (a, b))", true, Some(vec!["a".into(), "b".into()]), ), ( "CREATE TABLE my_table (a INT MASKING POLICY p USING (a, b))", false, Some(vec!["a".into(), "b".into()]), ), ] { match snowflake().verified_stmt(sql) { Statement::CreateTable(CreateTable { columns, .. }) => { assert_eq!( columns, vec![ColumnDef { name: "a".into(), data_type: DataType::Int(None), options: vec![ColumnOptionDef { name: None, option: ColumnOption::Policy(ColumnPolicy::MaskingPolicy( ColumnPolicyProperty { with, policy_name: ObjectName::from(vec![Ident::new("p")]), using_columns, } )) }], },] ); } _ => unreachable!(), } } } #[test] fn test_snowflake_create_table_with_columns_projection_policy() { for (sql, with) in [ ( "CREATE TABLE my_table (a INT WITH PROJECTION POLICY p)", true, ), ("CREATE TABLE my_table (a INT PROJECTION POLICY p)", false), ] { match snowflake().verified_stmt(sql) { Statement::CreateTable(CreateTable { columns, .. }) => { assert_eq!( columns, vec![ColumnDef { name: "a".into(), data_type: DataType::Int(None), options: vec![ColumnOptionDef { name: None, option: ColumnOption::Policy(ColumnPolicy::ProjectionPolicy( ColumnPolicyProperty { with, policy_name: ObjectName::from(vec![Ident::new("p")]), using_columns: None, } )) }], },] ); } _ => unreachable!(), } } } #[test] fn test_snowflake_create_table_with_columns_tags() { for (sql, with) in [ ( "CREATE TABLE my_table (a INT WITH TAG (A='TAG A', B='TAG B'))", true, ), ( "CREATE TABLE my_table (a INT TAG (A='TAG A', B='TAG B'))", false, ), ] { match snowflake().verified_stmt(sql) { Statement::CreateTable(CreateTable { columns, .. }) => { assert_eq!( columns, vec![ColumnDef { name: "a".into(), data_type: DataType::Int(None), options: vec![ColumnOptionDef { name: None, option: ColumnOption::Tags(TagsColumnOption { with, tags: vec![ Tag::new( ObjectName::from(vec![Ident::new("A")]), "TAG A".into() ), Tag::new( ObjectName::from(vec![Ident::new("B")]), "TAG B".into() ), ] }), }], },] ); } _ => unreachable!(), } } } #[test] fn test_snowflake_create_table_with_several_column_options() { let sql = concat!( "CREATE TABLE my_table (", "a INT IDENTITY WITH MASKING POLICY p1 USING (a, b) WITH TAG (A='TAG A', B='TAG B'), ", "b TEXT COLLATE 'de_DE' PROJECTION POLICY p2 TAG (C='TAG C', D='TAG D')", ")" ); match snowflake().verified_stmt(sql) { Statement::CreateTable(CreateTable { columns, .. }) => { assert_eq!( columns, vec![ ColumnDef { name: "a".into(), data_type: DataType::Int(None), options: vec![ ColumnOptionDef { name: None, option: ColumnOption::Identity(IdentityPropertyKind::Identity( IdentityProperty { parameters: None, order: None } )), }, ColumnOptionDef { name: None, option: ColumnOption::Policy(ColumnPolicy::MaskingPolicy( ColumnPolicyProperty { with: true, policy_name: ObjectName::from(vec![Ident::new("p1")]), using_columns: Some(vec!["a".into(), "b".into()]), } )), }, ColumnOptionDef { name: None, option: ColumnOption::Tags(TagsColumnOption { with: true, tags: vec![ Tag::new( ObjectName::from(vec![Ident::new("A")]), "TAG A".into() ), Tag::new( ObjectName::from(vec![Ident::new("B")]), "TAG B".into() ), ] }), } ], }, ColumnDef { name: "b".into(), data_type: DataType::Text, options: vec![ ColumnOptionDef { name: None, option: ColumnOption::Collation(ObjectName::from(vec![ Ident::with_quote('\'', "de_DE") ])), }, ColumnOptionDef { name: None, option: ColumnOption::Policy(ColumnPolicy::ProjectionPolicy( ColumnPolicyProperty { with: false, policy_name: ObjectName::from(vec![Ident::new("p2")]), using_columns: None, } )), }, ColumnOptionDef { name: None, option: ColumnOption::Tags(TagsColumnOption { with: false, tags: vec![ Tag::new( ObjectName::from(vec![Ident::new("C")]), "TAG C".into() ), Tag::new( ObjectName::from(vec![Ident::new("D")]), "TAG D".into() ), ] }), } ], }, ] ); } _ => unreachable!(), } } #[test] fn test_snowflake_create_iceberg_table_all_options() { match snowflake().verified_stmt("CREATE ICEBERG TABLE my_table (a INT, b INT) \ CLUSTER BY (a, b) EXTERNAL_VOLUME='volume' CATALOG='SNOWFLAKE' BASE_LOCATION='relative/path' CATALOG_SYNC='OPEN_CATALOG' \ STORAGE_SERIALIZATION_POLICY=COMPATIBLE COPY GRANTS CHANGE_TRACKING=TRUE DATA_RETENTION_TIME_IN_DAYS=5 MAX_DATA_EXTENSION_TIME_IN_DAYS=10 \ WITH AGGREGATION POLICY policy_name WITH ROW ACCESS POLICY policy_name ON (a) WITH TAG (A='TAG A', B='TAG B')") { Statement::CreateTable(CreateTable { name, cluster_by, base_location, external_volume, catalog, catalog_sync, storage_serialization_policy, change_tracking, copy_grants, data_retention_time_in_days, max_data_extension_time_in_days, with_aggregation_policy, with_row_access_policy, with_tags, .. }) => { assert_eq!("my_table", name.to_string()); assert_eq!( Some(WrappedCollection::Parentheses(vec![ Expr::Identifier(Ident::new("a")), Expr::Identifier(Ident::new("b")), ])), cluster_by ); assert_eq!("relative/path", base_location.unwrap()); assert_eq!("volume", external_volume.unwrap()); assert_eq!("SNOWFLAKE", catalog.unwrap()); assert_eq!("OPEN_CATALOG", catalog_sync.unwrap()); assert_eq!(StorageSerializationPolicy::Compatible, storage_serialization_policy.unwrap()); assert!(change_tracking.unwrap()); assert!(copy_grants); assert_eq!(Some(5), data_retention_time_in_days); assert_eq!(Some(10), max_data_extension_time_in_days); assert_eq!( Some("WITH ROW ACCESS POLICY policy_name ON (a)".to_string()), with_row_access_policy.map(|policy| policy.to_string()) ); assert_eq!( Some("policy_name".to_string()), with_aggregation_policy.map(|name| name.to_string()) ); assert_eq!(Some(vec![ Tag::new(ObjectName::from(vec![Ident::new("A")]), "TAG A".into()), Tag::new(ObjectName::from(vec![Ident::new("B")]), "TAG B".into()), ]), with_tags); } _ => unreachable!(), } } #[test] fn test_snowflake_create_iceberg_table() { match snowflake() .verified_stmt("CREATE ICEBERG TABLE my_table (a INT) BASE_LOCATION='relative_path'") { Statement::CreateTable(CreateTable { name, base_location, .. }) => { assert_eq!("my_table", name.to_string()); assert_eq!("relative_path", base_location.unwrap()); } _ => unreachable!(), } } #[test] fn test_snowflake_create_iceberg_table_without_location() { let res = snowflake().parse_sql_statements("CREATE ICEBERG TABLE my_table (a INT)"); assert_eq!( ParserError::ParserError("BASE_LOCATION is required for ICEBERG tables".to_string()), res.unwrap_err() ); } #[test] fn test_snowflake_create_table_trailing_options() { // Serialization to SQL assume that in `CREATE TABLE AS` the options come before the `AS ()` // but Snowflake supports also the other way around snowflake() .verified_stmt("CREATE TEMPORARY TABLE dst ON COMMIT PRESERVE ROWS AS (SELECT * FROM src)"); snowflake() .parse_sql_statements( "CREATE TEMPORARY TABLE dst AS (SELECT * FROM src) ON COMMIT PRESERVE ROWS", ) .unwrap(); // Same for `CREATE TABLE LIKE|CLONE`: snowflake().verified_stmt("CREATE TEMPORARY TABLE dst LIKE src ON COMMIT PRESERVE ROWS"); snowflake() .parse_sql_statements("CREATE TEMPORARY TABLE dst ON COMMIT PRESERVE ROWS LIKE src") .unwrap(); snowflake().verified_stmt("CREATE TEMPORARY TABLE dst CLONE src ON COMMIT PRESERVE ROWS"); snowflake() .parse_sql_statements("CREATE TEMPORARY TABLE dst ON COMMIT PRESERVE ROWS CLONE src") .unwrap(); } #[test] fn parse_sf_create_or_replace_view_with_comment_missing_equal() { assert!(snowflake_and_generic() .parse_sql_statements("CREATE OR REPLACE VIEW v COMMENT = 'hello, world' AS SELECT 1") .is_ok()); assert!(snowflake_and_generic() .parse_sql_statements("CREATE OR REPLACE VIEW v COMMENT 'hello, world' AS SELECT 1") .is_err()); } #[test] fn parse_sf_create_or_replace_with_comment_for_snowflake() { let sql = "CREATE OR REPLACE VIEW v COMMENT = 'hello, world' AS SELECT 1"; let dialect = test_utils::TestedDialects::new(vec![Box::new(SnowflakeDialect {}) as Box]); match dialect.verified_stmt(sql) { Statement::CreateView(CreateView { name, columns, or_replace, options, query, materialized, cluster_by, comment, with_no_schema_binding: late_binding, if_not_exists, temporary, .. }) => { assert_eq!("v", name.to_string()); assert_eq!(columns, vec![]); assert_eq!(options, CreateTableOptions::None); assert_eq!("SELECT 1", query.to_string()); assert!(!materialized); assert!(or_replace); assert_eq!(cluster_by, vec![]); assert!(comment.is_some()); assert_eq!(comment.expect("expected comment"), "hello, world"); assert!(!late_binding); assert!(!if_not_exists); assert!(!temporary); } _ => unreachable!(), } } #[test] fn parse_sf_create_table_or_view_with_dollar_quoted_comment() { // Snowflake transforms dollar quoted comments into a common comment in DDL representation of creation snowflake() .one_statement_parses_to( r#"CREATE OR REPLACE TEMPORARY VIEW foo.bar.baz ("COL_1" COMMENT $$comment 1$$) COMMENT = $$view comment$$ AS (SELECT 1)"#, r#"CREATE OR REPLACE TEMPORARY VIEW foo.bar.baz ("COL_1" COMMENT 'comment 1') COMMENT = 'view comment' AS (SELECT 1)"# ); snowflake().one_statement_parses_to( r#"CREATE TABLE my_table (a STRING COMMENT $$comment 1$$) COMMENT = $$table comment$$"#, r#"CREATE TABLE my_table (a STRING COMMENT 'comment 1') COMMENT = 'table comment'"#, ); } #[test] fn parse_create_dynamic_table() { snowflake().verified_stmt(r#"CREATE OR REPLACE DYNAMIC TABLE my_dynamic_table TARGET_LAG='20 minutes' WAREHOUSE=mywh AS SELECT product_id, product_name FROM staging_table"#); snowflake().verified_stmt(concat!( "CREATE DYNAMIC ICEBERG TABLE my_dynamic_table (date TIMESTAMP_NTZ, id NUMBER, content STRING)", " EXTERNAL_VOLUME='my_external_volume'", " CATALOG='SNOWFLAKE'", " BASE_LOCATION='my_iceberg_table'", " TARGET_LAG='20 minutes'", " WAREHOUSE=mywh", " AS SELECT product_id, product_name FROM staging_table" )); snowflake().verified_stmt(concat!( "CREATE DYNAMIC TABLE my_dynamic_table (date TIMESTAMP_NTZ, id NUMBER, content VARIANT)", " CLUSTER BY (date, id)", " TARGET_LAG='20 minutes'", " WAREHOUSE=mywh", " AS SELECT product_id, product_name FROM staging_table" )); snowflake().verified_stmt(concat!( "CREATE DYNAMIC TABLE my_cloned_dynamic_table", " CLONE my_dynamic_table", " AT(TIMESTAMP => TO_TIMESTAMP_TZ('04/05/2013 01:02:03', 'mm/dd/yyyy hh24:mi:ss'))" )); snowflake().verified_stmt(concat!( "CREATE DYNAMIC TABLE my_cloned_dynamic_table", " CLONE my_dynamic_table", " BEFORE(OFFSET => TO_TIMESTAMP_TZ('04/05/2013 01:02:03', 'mm/dd/yyyy hh24:mi:ss'))" )); snowflake().verified_stmt(concat!( "CREATE DYNAMIC TABLE my_dynamic_table", " TARGET_LAG='DOWNSTREAM'", " WAREHOUSE=mywh", " INITIALIZE=ON_SCHEDULE", " REQUIRE USER", " AS SELECT product_id, product_name FROM staging_table" )); snowflake().verified_stmt(concat!( "CREATE DYNAMIC TABLE my_dynamic_table", " TARGET_LAG='DOWNSTREAM'", " WAREHOUSE=mywh", " REFRESH_MODE=AUTO", " INITIALIZE=ON_SCHEDULE", " REQUIRE USER", " AS SELECT product_id, product_name FROM staging_table" )); snowflake().verified_stmt(concat!( "CREATE DYNAMIC TABLE my_dynamic_table", " TARGET_LAG='DOWNSTREAM'", " WAREHOUSE=mywh", " REFRESH_MODE=FULL", " INITIALIZE=ON_SCHEDULE", " REQUIRE USER", " AS SELECT product_id, product_name FROM staging_table" )); snowflake().verified_stmt(concat!( "CREATE DYNAMIC TABLE my_dynamic_table", " TARGET_LAG='DOWNSTREAM'", " WAREHOUSE=mywh", " REFRESH_MODE=INCREMENTAL", " INITIALIZE=ON_SCHEDULE", " REQUIRE USER", " AS SELECT product_id, product_name FROM staging_table" )); } #[test] fn test_sf_derived_table_in_parenthesis() { // Nesting a subquery in an extra set of parentheses is non-standard, // but supported in Snowflake SQL snowflake_and_generic().one_statement_parses_to( "SELECT * FROM ((SELECT 1) AS t)", "SELECT * FROM (SELECT 1) AS t", ); snowflake_and_generic().one_statement_parses_to( "SELECT * FROM (((SELECT 1) AS t))", "SELECT * FROM (SELECT 1) AS t", ); } #[test] fn test_single_table_in_parenthesis() { // Parenthesized table names are non-standard, but supported in Snowflake SQL snowflake_and_generic().one_statement_parses_to( "SELECT * FROM (a NATURAL JOIN (b))", "SELECT * FROM (a NATURAL JOIN b)", ); snowflake_and_generic().one_statement_parses_to( "SELECT * FROM (a NATURAL JOIN ((b)))", "SELECT * FROM (a NATURAL JOIN b)", ); } #[test] fn test_single_table_in_parenthesis_with_alias() { snowflake_and_generic().one_statement_parses_to( "SELECT * FROM (a NATURAL JOIN (b) c )", "SELECT * FROM (a NATURAL JOIN b c)", ); snowflake_and_generic().one_statement_parses_to( "SELECT * FROM (a NATURAL JOIN ((b)) c )", "SELECT * FROM (a NATURAL JOIN b c)", ); snowflake_and_generic().one_statement_parses_to( "SELECT * FROM (a NATURAL JOIN ( (b) c ) )", "SELECT * FROM (a NATURAL JOIN b c)", ); snowflake_and_generic().one_statement_parses_to( "SELECT * FROM (a NATURAL JOIN ( (b) as c ) )", "SELECT * FROM (a NATURAL JOIN b AS c)", ); snowflake_and_generic().one_statement_parses_to( "SELECT * FROM (a as alias1 NATURAL JOIN ( (b) c ) )", "SELECT * FROM (a AS alias1 NATURAL JOIN b c)", ); snowflake_and_generic().one_statement_parses_to( "SELECT * FROM (a alias1 NATURAL JOIN ( (b) c ) )", "SELECT * FROM (a alias1 NATURAL JOIN b c)", ); snowflake_and_generic().one_statement_parses_to( "SELECT * FROM (a as alias1 NATURAL JOIN ( (b) as c ) )", "SELECT * FROM (a AS alias1 NATURAL JOIN b AS c)", ); snowflake_and_generic().one_statement_parses_to( "SELECT * FROM (a NATURAL JOIN b) AS c", "SELECT * FROM (a NATURAL JOIN b) AS c", ); let res = snowflake().parse_sql_statements("SELECT * FROM (a b) c"); assert_eq!( ParserError::ParserError("duplicate alias b".to_string()), res.unwrap_err() ); } #[test] fn parse_array() { let sql = "SELECT CAST(a AS ARRAY) FROM customer"; let select = snowflake().verified_only_select(sql); assert_eq!( &Expr::Cast { kind: CastKind::Cast, expr: Box::new(Expr::Identifier(Ident::new("a"))), data_type: DataType::Array(ArrayElemTypeDef::None), array: false, format: None, }, expr_from_projection(only(&select.projection)) ); } #[test] fn parse_lateral_flatten() { snowflake().verified_only_select(r#"SELECT * FROM TABLE(FLATTEN(input => parse_json('{"a":1, "b":[77,88]}'), outer => true)) AS f"#); snowflake().verified_only_select(r#"SELECT emp.employee_ID, emp.last_name, index, value AS project_name FROM employees AS emp, LATERAL FLATTEN(INPUT => emp.project_names) AS proj_names"#); } // https://docs.snowflake.com/en/user-guide/querying-semistructured #[test] fn parse_semi_structured_data_traversal() { // see `tests/sqlparser_common.rs` -> `parse_semi_structured_data_traversal` for more test // cases. This test only has Snowflake-specific syntax like array access. // expressions are allowed in bracket notation let sql = r#"SELECT a[2 + 2] FROM t"#; let select = snowflake().verified_only_select(sql); assert_eq!( SelectItem::UnnamedExpr(Expr::JsonAccess { value: Box::new(Expr::Identifier(Ident::new("a"))), path: JsonPath { path: vec![JsonPathElem::Bracket { key: Expr::BinaryOp { left: Box::new(Expr::value(number("2"))), op: BinaryOperator::Plus, right: Box::new(Expr::value(number("2"))) }, }] }, }), select.projection[0] ); // dot and bracket notation can be mixed (starting with bracket case) // https://docs.snowflake.com/en/user-guide/querying-semistructured#dot-notation let sql = r#"SELECT a[0].foo.bar"#; let select = snowflake().verified_only_select(sql); assert_eq!( vec![SelectItem::UnnamedExpr(Expr::JsonAccess { value: Box::new(Expr::Identifier(Ident::new("a"))), path: JsonPath { path: vec![ JsonPathElem::Bracket { key: Expr::value(number("0")), }, JsonPathElem::Dot { key: "foo".to_owned(), quoted: false, }, JsonPathElem::Dot { key: "bar".to_owned(), quoted: false, } ] }, })], select.projection ); // a json access used as a key to another json access assert_eq!( snowflake().verified_expr("a[b:c]"), Expr::JsonAccess { value: Box::new(Expr::Identifier(Ident::new("a"))), path: JsonPath { path: vec![JsonPathElem::Bracket { key: Expr::JsonAccess { value: Box::new(Expr::Identifier(Ident::new("b"))), path: JsonPath { path: vec![JsonPathElem::Dot { key: "c".to_owned(), quoted: false }] } } }] } } ); // unquoted object keys cannot start with a digit assert_eq!( snowflake() .parse_sql_statements("SELECT a:42") .unwrap_err() .to_string(), "sql parser error: Expected: variant object key name, found: 42" ); // casting a json access and accessing an array element assert_eq!( snowflake().verified_expr("a:b::ARRAY[1]"), Expr::JsonAccess { value: Box::new(Expr::Cast { kind: CastKind::DoubleColon, expr: Box::new(Expr::JsonAccess { value: Box::new(Expr::Identifier(Ident::new("a"))), path: JsonPath { path: vec![JsonPathElem::Dot { key: "b".to_string(), quoted: false }] } }), data_type: DataType::Array(ArrayElemTypeDef::None), array: false, format: None, }), path: JsonPath { path: vec![JsonPathElem::Bracket { key: Expr::value(number("1")) }] } } ); } #[test] fn parse_delimited_identifiers() { // check that quoted identifiers in any position remain quoted after serialization let select = snowflake().verified_only_select( r#"SELECT "alias"."bar baz", "myfun"(), "simple id" AS "column alias" FROM "a table" AS "alias""#, ); // check FROM match only(select.from).relation { TableFactor::Table { name, alias, args, with_hints, version, .. } => { assert_eq!( ObjectName::from(vec![Ident::with_quote('"', "a table")]), name ); assert_eq!(Ident::with_quote('"', "alias"), alias.unwrap().name); assert!(args.is_none()); assert!(with_hints.is_empty()); assert!(version.is_none()); } _ => panic!("Expecting TableFactor::Table"), } // check SELECT assert_eq!(3, select.projection.len()); assert_eq!( &Expr::CompoundIdentifier(vec![ Ident::with_quote('"', "alias"), Ident::with_quote('"', "bar baz"), ]), expr_from_projection(&select.projection[0]), ); assert_eq!( &Expr::Function(Function { name: ObjectName::from(vec![Ident::with_quote('"', "myfun")]), uses_odbc_syntax: false, parameters: FunctionArguments::None, args: FunctionArguments::List(FunctionArgumentList { duplicate_treatment: None, args: vec![], clauses: vec![], }), filter: None, null_treatment: None, over: None, within_group: vec![], }), expr_from_projection(&select.projection[1]), ); match &select.projection[2] { SelectItem::ExprWithAlias { expr, alias } => { assert_eq!(&Expr::Identifier(Ident::with_quote('"', "simple id")), expr); assert_eq!(&Ident::with_quote('"', "column alias"), alias); } _ => panic!("Expected: ExprWithAlias"), } snowflake().verified_stmt(r#"CREATE TABLE "foo" ("bar" "int")"#); snowflake().verified_stmt(r#"ALTER TABLE foo ADD CONSTRAINT "bar" PRIMARY KEY (baz)"#); //TODO verified_stmt(r#"UPDATE foo SET "bar" = 5"#); } #[test] fn test_array_agg_func() { for sql in [ "SELECT ARRAY_AGG(x) WITHIN GROUP (ORDER BY x) AS a FROM T", "SELECT ARRAY_AGG(DISTINCT x) WITHIN GROUP (ORDER BY x ASC) FROM tbl", ] { snowflake().verified_stmt(sql); } } fn snowflake() -> TestedDialects { TestedDialects::new(vec![Box::new(SnowflakeDialect {})]) } fn snowflake_with_recursion_limit(recursion_limit: usize) -> TestedDialects { TestedDialects::new(vec![Box::new(SnowflakeDialect {})]).with_recursion_limit(recursion_limit) } fn snowflake_without_unescape() -> TestedDialects { TestedDialects::new_with_options( vec![Box::new(SnowflakeDialect {})], ParserOptions::new().with_unescape(false), ) } fn snowflake_and_generic() -> TestedDialects { TestedDialects::new(vec![ Box::new(SnowflakeDialect {}), Box::new(GenericDialect {}), ]) } #[test] fn test_select_wildcard_with_exclude() { let select = snowflake_and_generic().verified_only_select("SELECT * EXCLUDE (col_a) FROM data"); let expected = SelectItem::Wildcard(WildcardAdditionalOptions { opt_exclude: Some(ExcludeSelectItem::Multiple(vec![ObjectName::from( Ident::new("col_a"), )])), ..Default::default() }); assert_eq!(expected, select.projection[0]); let select = snowflake_and_generic() .verified_only_select("SELECT name.* EXCLUDE department_id FROM employee_table"); let expected = SelectItem::QualifiedWildcard( SelectItemQualifiedWildcardKind::ObjectName(ObjectName::from(vec![Ident::new("name")])), WildcardAdditionalOptions { opt_exclude: Some(ExcludeSelectItem::Single(ObjectName::from(Ident::new( "department_id", )))), ..Default::default() }, ); assert_eq!(expected, select.projection[0]); let select = snowflake_and_generic() .verified_only_select("SELECT * EXCLUDE (department_id, employee_id) FROM employee_table"); let expected = SelectItem::Wildcard(WildcardAdditionalOptions { opt_exclude: Some(ExcludeSelectItem::Multiple(vec![ ObjectName::from(Ident::new("department_id")), ObjectName::from(Ident::new("employee_id")), ])), ..Default::default() }); assert_eq!(expected, select.projection[0]); } #[test] fn test_select_wildcard_with_rename() { let select = snowflake_and_generic().verified_only_select("SELECT * RENAME col_a AS col_b FROM data"); let expected = SelectItem::Wildcard(WildcardAdditionalOptions { opt_rename: Some(RenameSelectItem::Single(IdentWithAlias { ident: Ident::new("col_a"), alias: Ident::new("col_b"), })), ..Default::default() }); assert_eq!(expected, select.projection[0]); let select = snowflake_and_generic().verified_only_select( "SELECT name.* RENAME (department_id AS new_dep, employee_id AS new_emp) FROM employee_table", ); let expected = SelectItem::QualifiedWildcard( SelectItemQualifiedWildcardKind::ObjectName(ObjectName::from(vec![Ident::new("name")])), WildcardAdditionalOptions { opt_rename: Some(RenameSelectItem::Multiple(vec![ IdentWithAlias { ident: Ident::new("department_id"), alias: Ident::new("new_dep"), }, IdentWithAlias { ident: Ident::new("employee_id"), alias: Ident::new("new_emp"), }, ])), ..Default::default() }, ); assert_eq!(expected, select.projection[0]); } #[test] fn test_select_wildcard_with_replace_and_rename() { let select = snowflake_and_generic().verified_only_select( "SELECT * REPLACE (col_z || col_z AS col_z) RENAME (col_z AS col_zz) FROM data", ); let expected = SelectItem::Wildcard(WildcardAdditionalOptions { opt_replace: Some(ReplaceSelectItem { items: vec![Box::new(ReplaceSelectElement { expr: Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("col_z"))), op: BinaryOperator::StringConcat, right: Box::new(Expr::Identifier(Ident::new("col_z"))), }, column_name: Ident::new("col_z"), as_keyword: true, })], }), opt_rename: Some(RenameSelectItem::Multiple(vec![IdentWithAlias { ident: Ident::new("col_z"), alias: Ident::new("col_zz"), }])), ..Default::default() }); assert_eq!(expected, select.projection[0]); // rename cannot precede replace // https://docs.snowflake.com/en/sql-reference/sql/select#parameters assert_eq!( snowflake_and_generic() .parse_sql_statements( "SELECT * RENAME (col_z AS col_zz) REPLACE (col_z || col_z AS col_z) FROM data" ) .unwrap_err() .to_string(), "sql parser error: Expected: end of statement, found: REPLACE" ); } #[test] fn test_select_wildcard_with_exclude_and_rename() { let select = snowflake_and_generic() .verified_only_select("SELECT * EXCLUDE col_z RENAME col_a AS col_b FROM data"); let expected = SelectItem::Wildcard(WildcardAdditionalOptions { opt_exclude: Some(ExcludeSelectItem::Single(ObjectName::from(Ident::new( "col_z", )))), opt_rename: Some(RenameSelectItem::Single(IdentWithAlias { ident: Ident::new("col_a"), alias: Ident::new("col_b"), })), ..Default::default() }); assert_eq!(expected, select.projection[0]); // rename cannot precede exclude // https://docs.snowflake.com/en/sql-reference/sql/select#parameters assert_eq!( snowflake_and_generic() .parse_sql_statements("SELECT * RENAME col_a AS col_b EXCLUDE col_z FROM data") .unwrap_err() .to_string(), "sql parser error: Expected: end of statement, found: EXCLUDE" ); } #[test] fn test_alter_table_swap_with() { let sql = "ALTER TABLE tab1 SWAP WITH tab2"; match alter_table_op_with_name(snowflake_and_generic().verified_stmt(sql), "tab1") { AlterTableOperation::SwapWith { table_name } => { assert_eq!("tab2", table_name.to_string()); } _ => unreachable!(), }; } #[test] fn test_alter_table_clustering() { let sql = r#"ALTER TABLE tab CLUSTER BY (c1, "c2", TO_DATE(c3))"#; match alter_table_op(snowflake_and_generic().verified_stmt(sql)) { AlterTableOperation::ClusterBy { exprs } => { assert_eq!( exprs, [ Expr::Identifier(Ident::new("c1")), Expr::Identifier(Ident::with_quote('"', "c2")), Expr::Function(Function { name: ObjectName::from(vec![Ident::new("TO_DATE")]), uses_odbc_syntax: false, parameters: FunctionArguments::None, args: FunctionArguments::List(FunctionArgumentList { args: vec![FunctionArg::Unnamed(FunctionArgExpr::Expr( Expr::Identifier(Ident::new("c3")) ))], duplicate_treatment: None, clauses: vec![], }), filter: None, null_treatment: None, over: None, within_group: vec![] }) ], ); } _ => unreachable!(), } snowflake_and_generic().verified_stmt("ALTER TABLE tbl DROP CLUSTERING KEY"); snowflake_and_generic().verified_stmt("ALTER TABLE tbl SUSPEND RECLUSTER"); snowflake_and_generic().verified_stmt("ALTER TABLE tbl RESUME RECLUSTER"); } #[test] fn test_alter_iceberg_table() { snowflake_and_generic().verified_stmt("ALTER ICEBERG TABLE tbl DROP CLUSTERING KEY"); snowflake_and_generic().verified_stmt("ALTER ICEBERG TABLE tbl SUSPEND RECLUSTER"); snowflake_and_generic().verified_stmt("ALTER ICEBERG TABLE tbl RESUME RECLUSTER"); } #[test] fn test_drop_stage() { match snowflake_and_generic().verified_stmt("DROP STAGE s1") { Statement::Drop { names, if_exists, .. } => { assert!(!if_exists); assert_eq!("s1", names[0].to_string()); } _ => unreachable!(), }; match snowflake_and_generic().verified_stmt("DROP STAGE IF EXISTS s1") { Statement::Drop { names, if_exists, .. } => { assert!(if_exists); assert_eq!("s1", names[0].to_string()); } _ => unreachable!(), }; snowflake_and_generic().one_statement_parses_to("DROP STAGE s1", "DROP STAGE s1"); snowflake_and_generic() .one_statement_parses_to("DROP STAGE IF EXISTS s1", "DROP STAGE IF EXISTS s1"); } #[test] fn parse_snowflake_declare_cursor() { for (sql, expected_name, expected_assigned_expr, expected_query_projections) in [ ( "DECLARE c1 CURSOR FOR SELECT id, price FROM invoices", "c1", None, Some(vec!["id", "price"]), ), ( "DECLARE c1 CURSOR FOR res", "c1", Some(DeclareAssignment::For( Expr::Identifier(Ident::new("res")).into(), )), None, ), ] { match snowflake().verified_stmt(sql) { Statement::Declare { mut stmts } => { assert_eq!(1, stmts.len()); let Declare { names, data_type, declare_type, assignment: assigned_expr, for_query, .. } = stmts.swap_remove(0); assert_eq!(vec![Ident::new(expected_name)], names); assert!(data_type.is_none()); assert_eq!(Some(DeclareType::Cursor), declare_type); assert_eq!(expected_assigned_expr, assigned_expr); assert_eq!( expected_query_projections, for_query.as_ref().map(|q| { match q.body.as_ref() { SetExpr::Select(q) => q .projection .iter() .map(|item| match item { SelectItem::UnnamedExpr(Expr::Identifier(ident)) => { ident.value.as_str() } _ => unreachable!(), }) .collect::>(), _ => unreachable!(), } }) ) } _ => unreachable!(), } } let error_sql = "DECLARE c1 CURSOR SELECT id FROM invoices"; assert_eq!( ParserError::ParserError("Expected: FOR, found: SELECT".to_owned()), snowflake().parse_sql_statements(error_sql).unwrap_err() ); let error_sql = "DECLARE c1 CURSOR res"; assert_eq!( ParserError::ParserError("Expected: FOR, found: res".to_owned()), snowflake().parse_sql_statements(error_sql).unwrap_err() ); } #[test] fn parse_snowflake_declare_result_set() { for (sql, expected_name, expected_assigned_expr) in [ ( "DECLARE res RESULTSET DEFAULT 42", "res", Some(DeclareAssignment::Default(Expr::value(number("42")).into())), ), ( "DECLARE res RESULTSET := 42", "res", Some(DeclareAssignment::DuckAssignment( Expr::value(number("42")).into(), )), ), ("DECLARE res RESULTSET", "res", None), ] { match snowflake().verified_stmt(sql) { Statement::Declare { mut stmts } => { assert_eq!(1, stmts.len()); let Declare { names, data_type, declare_type, assignment: assigned_expr, for_query, .. } = stmts.swap_remove(0); assert_eq!(vec![Ident::new(expected_name)], names); assert!(data_type.is_none()); assert!(for_query.is_none()); assert_eq!(Some(DeclareType::ResultSet), declare_type); assert_eq!(expected_assigned_expr, assigned_expr); } _ => unreachable!(), } } let sql = "DECLARE res RESULTSET DEFAULT (SELECT price FROM invoices)"; assert_eq!(snowflake().verified_stmt(sql).to_string(), sql); let error_sql = "DECLARE res RESULTSET DEFAULT"; assert_eq!( ParserError::ParserError("Expected: an expression, found: EOF".to_owned()), snowflake().parse_sql_statements(error_sql).unwrap_err() ); let error_sql = "DECLARE res RESULTSET :="; assert_eq!( ParserError::ParserError("Expected: an expression, found: EOF".to_owned()), snowflake().parse_sql_statements(error_sql).unwrap_err() ); } #[test] fn parse_snowflake_declare_exception() { for (sql, expected_name, expected_assigned_expr) in [ ( "DECLARE ex EXCEPTION (42, 'ERROR')", "ex", Some(DeclareAssignment::Expr( Expr::Tuple(vec![ Expr::value(number("42")), Expr::Value((Value::SingleQuotedString("ERROR".to_string())).with_empty_span()), ]) .into(), )), ), ("DECLARE ex EXCEPTION", "ex", None), ] { match snowflake().verified_stmt(sql) { Statement::Declare { mut stmts } => { assert_eq!(1, stmts.len()); let Declare { names, data_type, declare_type, assignment: assigned_expr, for_query, .. } = stmts.swap_remove(0); assert_eq!(vec![Ident::new(expected_name)], names); assert!(data_type.is_none()); assert!(for_query.is_none()); assert_eq!(Some(DeclareType::Exception), declare_type); assert_eq!(expected_assigned_expr, assigned_expr); } _ => unreachable!(), } } } #[test] fn parse_snowflake_declare_variable() { for (sql, expected_name, expected_data_type, expected_assigned_expr) in [ ( "DECLARE profit TEXT DEFAULT 42", "profit", Some(DataType::Text), Some(DeclareAssignment::Default(Expr::value(number("42")).into())), ), ( "DECLARE profit DEFAULT 42", "profit", None, Some(DeclareAssignment::Default(Expr::value(number("42")).into())), ), ("DECLARE profit TEXT", "profit", Some(DataType::Text), None), ("DECLARE profit", "profit", None, None), ] { match snowflake().verified_stmt(sql) { Statement::Declare { mut stmts } => { assert_eq!(1, stmts.len()); let Declare { names, data_type, declare_type, assignment: assigned_expr, for_query, .. } = stmts.swap_remove(0); assert_eq!(vec![Ident::new(expected_name)], names); assert!(for_query.is_none()); assert_eq!(expected_data_type, data_type); assert_eq!(None, declare_type); assert_eq!(expected_assigned_expr, assigned_expr); } _ => unreachable!(), } } snowflake().one_statement_parses_to("DECLARE profit;", "DECLARE profit"); let error_sql = "DECLARE profit INT 2"; assert_eq!( ParserError::ParserError("Expected: end of statement, found: 2".to_owned()), snowflake().parse_sql_statements(error_sql).unwrap_err() ); let error_sql = "DECLARE profit INT DEFAULT"; assert_eq!( ParserError::ParserError("Expected: an expression, found: EOF".to_owned()), snowflake().parse_sql_statements(error_sql).unwrap_err() ); let error_sql = "DECLARE profit DEFAULT"; assert_eq!( ParserError::ParserError("Expected: an expression, found: EOF".to_owned()), snowflake().parse_sql_statements(error_sql).unwrap_err() ); } #[test] fn parse_snowflake_declare_multi_statements() { let sql = concat!( "DECLARE profit DEFAULT 42; ", "res RESULTSET DEFAULT (SELECT price FROM invoices); ", "c1 CURSOR FOR res; ", "ex EXCEPTION (-20003, 'ERROR: Could not create table.')" ); match snowflake().verified_stmt(sql) { Statement::Declare { stmts } => { let actual = stmts .iter() .map(|stmt| (stmt.names[0].value.as_str(), stmt.declare_type.clone())) .collect::>(); assert_eq!( vec![ ("profit", None), ("res", Some(DeclareType::ResultSet)), ("c1", Some(DeclareType::Cursor)), ("ex", Some(DeclareType::Exception)), ], actual ); } _ => unreachable!(), } let error_sql = "DECLARE profit DEFAULT 42 c1 CURSOR FOR res;"; assert_eq!( ParserError::ParserError("Expected: end of statement, found: c1".to_owned()), snowflake().parse_sql_statements(error_sql).unwrap_err() ); } #[test] fn test_create_stage() { let sql = "CREATE STAGE s1.s2"; match snowflake().verified_stmt(sql) { Statement::CreateStage { or_replace, temporary, if_not_exists, name, comment, .. } => { assert!(!or_replace); assert!(!temporary); assert!(!if_not_exists); assert_eq!("s1.s2", name.to_string()); assert!(comment.is_none()); } _ => unreachable!(), }; assert_eq!(snowflake().verified_stmt(sql).to_string(), sql); let extended_sql = concat!( "CREATE OR REPLACE TEMPORARY STAGE IF NOT EXISTS s1.s2 ", "COMMENT='some-comment'" ); match snowflake().verified_stmt(extended_sql) { Statement::CreateStage { or_replace, temporary, if_not_exists, name, stage_params, comment, .. } => { assert!(or_replace); assert!(temporary); assert!(if_not_exists); assert!(stage_params.url.is_none()); assert!(stage_params.endpoint.is_none()); assert_eq!("s1.s2", name.to_string()); assert_eq!("some-comment", comment.unwrap()); } _ => unreachable!(), }; assert_eq!( snowflake().verified_stmt(extended_sql).to_string(), extended_sql ); } #[test] fn test_create_stage_with_stage_params() { let sql = concat!( "CREATE OR REPLACE STAGE my_ext_stage ", "URL='s3://load/files/' ", "STORAGE_INTEGRATION=myint ", "ENDPOINT='' ", "CREDENTIALS=(AWS_KEY_ID='1a2b3c' AWS_SECRET_KEY='4x5y6z') ", "ENCRYPTION=(MASTER_KEY='key' TYPE='AWS_SSE_KMS')" ); match snowflake().verified_stmt(sql) { Statement::CreateStage { stage_params, .. } => { assert_eq!("s3://load/files/", stage_params.url.unwrap()); assert_eq!("myint", stage_params.storage_integration.unwrap()); assert_eq!( "", stage_params.endpoint.unwrap() ); assert!(stage_params.credentials.options.contains(&KeyValueOption { option_name: "AWS_KEY_ID".to_string(), option_value: KeyValueOptionKind::Single( Value::SingleQuotedString("1a2b3c".to_string()).with_empty_span() ), })); assert!(stage_params.credentials.options.contains(&KeyValueOption { option_name: "AWS_SECRET_KEY".to_string(), option_value: KeyValueOptionKind::Single( Value::SingleQuotedString("4x5y6z".to_string()).with_empty_span() ), })); assert!(stage_params.encryption.options.contains(&KeyValueOption { option_name: "MASTER_KEY".to_string(), option_value: KeyValueOptionKind::Single( Value::SingleQuotedString("key".to_string()).with_empty_span() ), })); assert!(stage_params.encryption.options.contains(&KeyValueOption { option_name: "TYPE".to_string(), option_value: KeyValueOptionKind::Single( Value::SingleQuotedString("AWS_SSE_KMS".to_string()).with_empty_span() ), })); } _ => unreachable!(), }; assert_eq!(snowflake().verified_stmt(sql).to_string(), sql); } #[test] fn test_create_stage_with_directory_table_params() { let sql = concat!( "CREATE OR REPLACE STAGE my_ext_stage ", "URL='s3://load/files/' ", "DIRECTORY=(ENABLE=true REFRESH_ON_CREATE=false NOTIFICATION_INTEGRATION='some-string')" ); match snowflake().verified_stmt(sql) { Statement::CreateStage { directory_table_params, .. } => { assert!(directory_table_params.options.contains(&KeyValueOption { option_name: "ENABLE".to_string(), option_value: KeyValueOptionKind::Single(Value::Boolean(true).with_empty_span()), })); assert!(directory_table_params.options.contains(&KeyValueOption { option_name: "REFRESH_ON_CREATE".to_string(), option_value: KeyValueOptionKind::Single(Value::Boolean(false).with_empty_span()), })); assert!(directory_table_params.options.contains(&KeyValueOption { option_name: "NOTIFICATION_INTEGRATION".to_string(), option_value: KeyValueOptionKind::Single( Value::SingleQuotedString("some-string".to_string()).with_empty_span() ), })); } _ => unreachable!(), }; assert_eq!(snowflake().verified_stmt(sql).to_string(), sql); } #[test] fn test_create_stage_with_file_format() { let sql = concat!( "CREATE OR REPLACE STAGE my_ext_stage ", "URL='s3://load/files/' ", r#"FILE_FORMAT=(COMPRESSION=AUTO BINARY_FORMAT=HEX ESCAPE='\\')"# ); match snowflake_without_unescape().verified_stmt(sql) { Statement::CreateStage { file_format, .. } => { assert!(file_format.options.contains(&KeyValueOption { option_name: "COMPRESSION".to_string(), option_value: KeyValueOptionKind::Single( Value::Placeholder("AUTO".to_string()).with_empty_span() ), })); assert!(file_format.options.contains(&KeyValueOption { option_name: "BINARY_FORMAT".to_string(), option_value: KeyValueOptionKind::Single( Value::Placeholder("HEX".to_string()).with_empty_span() ), })); assert!(file_format.options.contains(&KeyValueOption { option_name: "ESCAPE".to_string(), option_value: KeyValueOptionKind::Single( Value::SingleQuotedString(r#"\\"#.to_string()).with_empty_span() ), })); } _ => unreachable!(), }; assert_eq!( snowflake_without_unescape().verified_stmt(sql).to_string(), sql ); } #[test] fn test_create_stage_with_copy_options() { let sql = concat!( "CREATE OR REPLACE STAGE my_ext_stage ", "URL='s3://load/files/' ", "COPY_OPTIONS=(ON_ERROR=CONTINUE FORCE=true)" ); match snowflake().verified_stmt(sql) { Statement::CreateStage { copy_options, .. } => { assert!(copy_options.options.contains(&KeyValueOption { option_name: "ON_ERROR".to_string(), option_value: KeyValueOptionKind::Single( Value::Placeholder("CONTINUE".to_string()).with_empty_span() ), })); assert!(copy_options.options.contains(&KeyValueOption { option_name: "FORCE".to_string(), option_value: KeyValueOptionKind::Single(Value::Boolean(true).with_empty_span()), })); } _ => unreachable!(), }; assert_eq!(snowflake().verified_stmt(sql).to_string(), sql); } #[test] fn test_copy_into() { let sql = concat!( "COPY INTO my_company.emp_basic ", "FROM 'gcs://mybucket/./../a.csv'" ); match snowflake().verified_stmt(sql) { Statement::CopyIntoSnowflake { kind, into, from_obj, files, pattern, validation_mode, .. } => { assert_eq!(kind, CopyIntoSnowflakeKind::Table); assert_eq!( into, ObjectName::from(vec![Ident::new("my_company"), Ident::new("emp_basic")]) ); assert_eq!( from_obj, Some(ObjectName::from(vec![Ident::with_quote( '\'', "gcs://mybucket/./../a.csv" )])) ); assert!(files.is_none()); assert!(pattern.is_none()); assert!(validation_mode.is_none()); } _ => unreachable!(), }; assert_eq!(snowflake().verified_stmt(sql).to_string(), sql); let sql = concat!("COPY INTO 's3://a/b/c/data.parquet' ", "FROM db.sc.tbl ", "PARTITION BY ('date=' || to_varchar(dt, 'YYYY-MM-DD') || '/hour=' || to_varchar(date_part(hour, ts)))"); match snowflake().verified_stmt(sql) { Statement::CopyIntoSnowflake { kind, into, from_obj, from_query, partition, .. } => { assert_eq!(kind, CopyIntoSnowflakeKind::Location); assert_eq!( into, ObjectName::from(vec![Ident::with_quote('\'', "s3://a/b/c/data.parquet")]) ); assert_eq!( from_obj, Some(ObjectName::from(vec![ Ident::new("db"), Ident::new("sc"), Ident::new("tbl") ])) ); assert!(from_query.is_none()); assert!(partition.is_some()); } _ => unreachable!(), }; assert_eq!(snowflake().verified_stmt(sql).to_string(), sql); let sql = concat!( "COPY INTO 's3://a/b/c/data.parquet' ", "FROM (SELECT * FROM tbl)" ); match snowflake().verified_stmt(sql) { Statement::CopyIntoSnowflake { kind, into, from_obj, from_query, .. } => { assert_eq!(kind, CopyIntoSnowflakeKind::Location); assert_eq!( into, ObjectName::from(vec![Ident::with_quote('\'', "s3://a/b/c/data.parquet")]) ); assert!(from_query.is_some()); assert!(from_obj.is_none()); } _ => unreachable!(), }; assert_eq!(snowflake().verified_stmt(sql).to_string(), sql); } #[test] fn test_copy_into_with_stage_params() { let sql = concat!( "COPY INTO my_company.emp_basic ", "FROM 's3://load/files/' ", "STORAGE_INTEGRATION=myint ", "ENDPOINT='' ", "CREDENTIALS=(AWS_KEY_ID='1a2b3c' AWS_SECRET_KEY='4x5y6z') ", "ENCRYPTION=(MASTER_KEY='key' TYPE='AWS_SSE_KMS')" ); match snowflake().verified_stmt(sql) { Statement::CopyIntoSnowflake { from_obj, stage_params, .. } => { //assert_eq!("s3://load/files/", stage_params.url.unwrap()); assert_eq!( from_obj, Some(ObjectName::from(vec![Ident::with_quote( '\'', "s3://load/files/" )])) ); assert_eq!("myint", stage_params.storage_integration.unwrap()); assert_eq!( "", stage_params.endpoint.unwrap() ); assert!(stage_params.credentials.options.contains(&KeyValueOption { option_name: "AWS_KEY_ID".to_string(), option_value: KeyValueOptionKind::Single( Value::SingleQuotedString("1a2b3c".to_string()).with_empty_span() ), })); assert!(stage_params.credentials.options.contains(&KeyValueOption { option_name: "AWS_SECRET_KEY".to_string(), option_value: KeyValueOptionKind::Single( Value::SingleQuotedString("4x5y6z".to_string()).with_empty_span() ), })); assert!(stage_params.encryption.options.contains(&KeyValueOption { option_name: "MASTER_KEY".to_string(), option_value: KeyValueOptionKind::Single( Value::SingleQuotedString("key".to_string()).with_empty_span() ), })); assert!(stage_params.encryption.options.contains(&KeyValueOption { option_name: "TYPE".to_string(), option_value: KeyValueOptionKind::Single( Value::SingleQuotedString("AWS_SSE_KMS".to_string()).with_empty_span() ), })); } _ => unreachable!(), }; assert_eq!(snowflake().verified_stmt(sql).to_string(), sql); // stage params within copy into with transformations let sql = concat!( "COPY INTO my_company.emp_basic FROM ", "(SELECT t1.$1 FROM 's3://load/files/' STORAGE_INTEGRATION=myint)", ); match snowflake().verified_stmt(sql) { Statement::CopyIntoSnowflake { from_obj, stage_params, .. } => { assert_eq!( from_obj, Some(ObjectName::from(vec![Ident::with_quote( '\'', "s3://load/files/" )])) ); assert_eq!("myint", stage_params.storage_integration.unwrap()); } _ => unreachable!(), } } #[test] fn test_copy_into_with_files_and_pattern_and_verification() { let sql = concat!( "COPY INTO my_company.emp_basic ", "FROM 'gcs://mybucket/./../a.csv' AS some_alias ", "FILES = ('file1.json', 'file2.json') ", "PATTERN = '.*employees0[1-5].csv.gz' ", "VALIDATION_MODE = RETURN_7_ROWS" ); match snowflake().verified_stmt(sql) { Statement::CopyIntoSnowflake { files, pattern, validation_mode, from_obj_alias, .. } => { assert_eq!(files.unwrap(), vec!["file1.json", "file2.json"]); assert_eq!(pattern.unwrap(), ".*employees0[1-5].csv.gz"); assert_eq!(validation_mode.unwrap(), "RETURN_7_ROWS"); assert_eq!(from_obj_alias.unwrap(), Ident::new("some_alias")); } _ => unreachable!(), } assert_eq!(snowflake().verified_stmt(sql).to_string(), sql); } #[test] fn test_copy_into_with_transformations() { let sql = concat!( "COPY INTO my_company.emp_basic FROM ", "(SELECT t1.$1:st AS st, $1:index, t2.$1, 4, '5' AS const_str FROM @schema.general_finished AS T) ", "FILES = ('file1.json', 'file2.json') ", "PATTERN = '.*employees0[1-5].csv.gz' ", "VALIDATION_MODE = RETURN_7_ROWS" ); match snowflake().verified_stmt(sql) { Statement::CopyIntoSnowflake { from_obj, from_transformations, .. } => { assert_eq!( from_obj, Some(ObjectName::from(vec![ Ident::new("@schema"), Ident::new("general_finished") ])) ); assert_eq!( from_transformations.as_ref().unwrap()[0], StageLoadSelectItemKind::StageLoadSelectItem(StageLoadSelectItem { alias: Some(Ident::new("t1")), file_col_num: 1, element: Some(Ident::new("st")), item_as: Some(Ident::new("st")) }) ); assert_eq!( from_transformations.as_ref().unwrap()[1], StageLoadSelectItemKind::StageLoadSelectItem(StageLoadSelectItem { alias: None, file_col_num: 1, element: Some(Ident::new("index")), item_as: None }) ); assert_eq!( from_transformations.as_ref().unwrap()[2], StageLoadSelectItemKind::StageLoadSelectItem(StageLoadSelectItem { alias: Some(Ident::new("t2")), file_col_num: 1, element: None, item_as: None }) ); assert_eq!( from_transformations.as_ref().unwrap()[3], StageLoadSelectItemKind::SelectItem(SelectItem::UnnamedExpr(Expr::Value( Value::Number("4".parse().unwrap(), false).into() ))) ); assert_eq!( from_transformations.as_ref().unwrap()[4], StageLoadSelectItemKind::SelectItem(SelectItem::ExprWithAlias { expr: Expr::Value(Value::SingleQuotedString("5".parse().unwrap()).into()), alias: Ident::new("const_str".to_string()) }) ); } _ => unreachable!(), } assert_eq!(snowflake().verified_stmt(sql).to_string(), sql); // Test optional AS keyword to denote an alias for the stage let sql1 = concat!( "COPY INTO my_company.emp_basic FROM ", "(SELECT t1.$1:st AS st, $1:index, t2.$1, 4, '5' AS const_str FROM @schema.general_finished T) " ); snowflake().parse_sql_statements(sql1).unwrap(); } #[test] fn test_copy_into_file_format() { let sql = concat!( "COPY INTO my_company.emp_basic ", "FROM 'gcs://mybucket/./../a.csv' ", "FILES = ('file1.json', 'file2.json') ", "PATTERN = '.*employees0[1-5].csv.gz' ", r#"FILE_FORMAT=(COMPRESSION=AUTO BINARY_FORMAT=HEX ESCAPE='\\')"# ); match snowflake_without_unescape().verified_stmt(sql) { Statement::CopyIntoSnowflake { file_format, .. } => { assert!(file_format.options.contains(&KeyValueOption { option_name: "COMPRESSION".to_string(), option_value: KeyValueOptionKind::Single( Value::Placeholder("AUTO".to_string()).with_empty_span() ), })); assert!(file_format.options.contains(&KeyValueOption { option_name: "BINARY_FORMAT".to_string(), option_value: KeyValueOptionKind::Single( Value::Placeholder("HEX".to_string()).with_empty_span() ), })); assert!(file_format.options.contains(&KeyValueOption { option_name: "ESCAPE".to_string(), option_value: KeyValueOptionKind::Single( Value::SingleQuotedString(r#"\\"#.to_string()).with_empty_span() ), })); } _ => unreachable!(), } assert_eq!( snowflake_without_unescape().verified_stmt(sql).to_string(), sql ); // Test commas in file format let sql = concat!( "COPY INTO my_company.emp_basic ", "FROM 'gcs://mybucket/./../a.csv' ", "FILES = ('file1.json', 'file2.json') ", "PATTERN = '.*employees0[1-5].csv.gz' ", r#"FILE_FORMAT=(COMPRESSION=AUTO, BINARY_FORMAT=HEX, ESCAPE='\\')"# ); match snowflake_without_unescape() .parse_sql_statements(sql) .unwrap() .first() .unwrap() { Statement::CopyIntoSnowflake { file_format, .. } => { assert!(file_format.options.contains(&KeyValueOption { option_name: "COMPRESSION".to_string(), option_value: KeyValueOptionKind::Single( Value::Placeholder("AUTO".to_string()).with_empty_span() ), })); assert!(file_format.options.contains(&KeyValueOption { option_name: "BINARY_FORMAT".to_string(), option_value: KeyValueOptionKind::Single( Value::Placeholder("HEX".to_string()).with_empty_span() ), })); assert!(file_format.options.contains(&KeyValueOption { option_name: "ESCAPE".to_string(), option_value: KeyValueOptionKind::Single( Value::SingleQuotedString(r#"\\"#.to_string()).with_empty_span() ), })); } _ => unreachable!(), } } #[test] fn test_copy_into_copy_options() { let sql = concat!( "COPY INTO my_company.emp_basic ", "FROM 'gcs://mybucket/./../a.csv' ", "FILES = ('file1.json', 'file2.json') ", "PATTERN = '.*employees0[1-5].csv.gz' ", "COPY_OPTIONS=(ON_ERROR=CONTINUE FORCE=true)" ); match snowflake().verified_stmt(sql) { Statement::CopyIntoSnowflake { copy_options, .. } => { assert!(copy_options.options.contains(&KeyValueOption { option_name: "ON_ERROR".to_string(), option_value: KeyValueOptionKind::Single( Value::Placeholder("CONTINUE".to_string()).with_empty_span() ), })); assert!(copy_options.options.contains(&KeyValueOption { option_name: "FORCE".to_string(), option_value: KeyValueOptionKind::Single(Value::Boolean(true).with_empty_span()), })); } _ => unreachable!(), }; assert_eq!(snowflake().verified_stmt(sql).to_string(), sql); } #[test] fn test_snowflake_stage_object_names_into_location() { let mut allowed_object_names = [ ObjectName::from(vec![Ident::new("@namespace"), Ident::new("%table_name")]), ObjectName::from(vec![ Ident::new("@namespace"), Ident::new("%table_name/path"), ]), ObjectName::from(vec![ Ident::new("@namespace"), Ident::new("stage_name/path"), ]), ObjectName::from(vec![Ident::new("@~/path")]), ]; let allowed_names_into_location = [ "@namespace.%table_name", "@namespace.%table_name/path", "@namespace.stage_name/path", "@~/path", ]; for it in allowed_names_into_location .iter() .zip(allowed_object_names.iter_mut()) { let (formatted_name, object_name) = it; let sql = format!("COPY INTO {formatted_name} FROM 'gcs://mybucket/./../a.csv'"); match snowflake().verified_stmt(&sql) { Statement::CopyIntoSnowflake { into, .. } => { assert_eq!(into.0, object_name.0) } _ => unreachable!(), } } } #[test] fn test_snowflake_stage_object_names_into_table() { let mut allowed_object_names = [ ObjectName::from(vec![Ident::new("my_company"), Ident::new("emp_basic")]), ObjectName::from(vec![Ident::new("emp_basic")]), ]; let allowed_names_into_table = ["my_company.emp_basic", "emp_basic"]; for it in allowed_names_into_table .iter() .zip(allowed_object_names.iter_mut()) { let (formatted_name, object_name) = it; let sql = format!("COPY INTO {formatted_name} FROM 'gcs://mybucket/./../a.csv'"); match snowflake().verified_stmt(&sql) { Statement::CopyIntoSnowflake { into, .. } => { assert_eq!(into.0, object_name.0) } _ => unreachable!(), } } } #[test] fn test_snowflake_copy_into() { let sql = "COPY INTO a.b FROM @namespace.stage_name"; assert_eq!(snowflake().verified_stmt(sql).to_string(), sql); match snowflake().verified_stmt(sql) { Statement::CopyIntoSnowflake { into, from_obj, .. } => { assert_eq!( into, ObjectName::from(vec![Ident::new("a"), Ident::new("b")]) ); assert_eq!( from_obj, Some(ObjectName::from(vec![ Ident::new("@namespace"), Ident::new("stage_name") ])) ) } _ => unreachable!(), } // Test for non-ident characters in stage names let sql = "COPY INTO a.b FROM @namespace.stage_name/x@x~x%x+/20250723_data-x"; assert_eq!(snowflake().verified_stmt(sql).to_string(), sql); match snowflake().verified_stmt(sql) { Statement::CopyIntoSnowflake { into, from_obj, .. } => { assert_eq!( into, ObjectName::from(vec![Ident::new("a"), Ident::new("b")]) ); assert_eq!( from_obj, Some(ObjectName::from(vec![ Ident::new("@namespace"), Ident::new("stage_name/x@x~x%x+/20250723_data-x") ])) ) } _ => unreachable!(), } } #[test] fn test_snowflake_copy_into_stage_name_ends_with_parens() { let sql = "COPY INTO SCHEMA.SOME_MONITORING_SYSTEM FROM (SELECT t.$1:st AS st FROM @schema.general_finished)"; assert_eq!(snowflake().verified_stmt(sql).to_string(), sql); match snowflake().verified_stmt(sql) { Statement::CopyIntoSnowflake { into, from_obj, .. } => { assert_eq!( into, ObjectName::from(vec![ Ident::new("SCHEMA"), Ident::new("SOME_MONITORING_SYSTEM") ]) ); assert_eq!( from_obj, Some(ObjectName::from(vec![ Ident::new("@schema"), Ident::new("general_finished") ])) ) } _ => unreachable!(), } } #[test] fn test_snowflake_stage_name_with_special_chars() { // Stage path with '=' (Hive-style partitioning) snowflake().verified_stmt("SELECT * FROM @stage/day=18/23.parquet"); // Stage path with ':' (time-based partitioning) snowflake().verified_stmt("SELECT * FROM @stage/0:18:23/23.parquet"); // COPY INTO with '=' in stage path snowflake().verified_stmt("COPY INTO my_table FROM @stage/day=18/file.parquet"); // COPY INTO with ':' in stage path snowflake().verified_stmt("COPY INTO my_table FROM @stage/0:18:23/file.parquet"); } #[test] fn test_snowflake_trim() { let real_sql = r#"SELECT customer_id, TRIM(sub_items.value:item_price_id, '"', "a") AS item_price_id FROM models_staging.subscriptions"#; assert_eq!(snowflake().verified_stmt(real_sql).to_string(), real_sql); let sql_only_select = "SELECT TRIM('xyz', 'a')"; let select = snowflake().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()), snowflake().parse_sql_statements(error_sql).unwrap_err() ); } #[test] fn test_number_placeholder() { let sql_only_select = "SELECT :1"; let select = snowflake().verified_only_select(sql_only_select); assert_eq!( &Expr::Value((Value::Placeholder(":1".into())).with_empty_span()), expr_from_projection(only(&select.projection)) ); snowflake() .parse_sql_statements("alter role 1 with name = 'foo'") .expect_err("should have failed"); } #[test] fn parse_position_not_function_columns() { snowflake_and_generic() .verified_stmt("SELECT position FROM tbl1 WHERE position NOT IN ('first', 'last')"); } #[test] fn parse_subquery_function_argument() { // Snowflake allows passing an unparenthesized subquery as the single // argument to a function. snowflake().verified_stmt("SELECT parse_json(SELECT '{}')"); // Subqueries that begin with WITH work too. snowflake() .verified_stmt("SELECT parse_json(WITH q AS (SELECT '{}' AS foo) SELECT foo FROM q)"); // Commas are parsed as part of the subquery, not additional arguments to // the function. snowflake().verified_stmt("SELECT func(SELECT 1, 2)"); } #[test] fn parse_division_correctly() { snowflake_and_generic().one_statement_parses_to( "SELECT field/1000 FROM tbl1", "SELECT field / 1000 FROM tbl1", ); snowflake_and_generic().one_statement_parses_to( "SELECT tbl1.field/tbl2.field FROM tbl1 JOIN tbl2 ON tbl1.id = tbl2.entity_id", "SELECT tbl1.field / tbl2.field FROM tbl1 JOIN tbl2 ON tbl1.id = tbl2.entity_id", ); } #[test] fn parse_pivot_of_table_factor_derived() { snowflake().verified_stmt( "SELECT * FROM (SELECT place_id, weekday, open FROM times AS p) PIVOT(max(open) FOR weekday IN (0, 1, 2, 3, 4, 5, 6)) AS p (place_id, open_sun, open_mon, open_tue, open_wed, open_thu, open_fri, open_sat)" ); } #[test] fn parse_top() { snowflake().one_statement_parses_to( "SELECT TOP 4 c1 FROM testtable", "SELECT TOP 4 c1 FROM testtable", ); } #[test] fn parse_extract_custom_part() { let sql = "SELECT EXTRACT(eod FROM d)"; let select = snowflake_and_generic().verified_only_select(sql); assert_eq!( &Expr::Extract { field: DateTimeField::Custom(Ident::new("eod")), syntax: ExtractSyntax::From, expr: Box::new(Expr::Identifier(Ident::new("d"))), }, expr_from_projection(only(&select.projection)), ); } #[test] fn parse_extract_comma() { let sql = "SELECT EXTRACT(HOUR, d)"; let select = snowflake_and_generic().verified_only_select(sql); assert_eq!( &Expr::Extract { field: DateTimeField::Hour, syntax: ExtractSyntax::Comma, expr: Box::new(Expr::Identifier(Ident::new("d"))), }, expr_from_projection(only(&select.projection)), ); } #[test] fn parse_extract_comma_quoted() { let sql = "SELECT EXTRACT('hour', d)"; let select = snowflake_and_generic().verified_only_select(sql); assert_eq!( &Expr::Extract { field: DateTimeField::Custom(Ident::with_quote('\'', "hour")), syntax: ExtractSyntax::Comma, expr: Box::new(Expr::Identifier(Ident::new("d"))), }, expr_from_projection(only(&select.projection)), ); } #[test] fn parse_comma_outer_join() { // compound identifiers let case1 = snowflake().verified_only_select("SELECT t1.c1, t2.c2 FROM t1, t2 WHERE t1.c1 = t2.c2 (+)"); assert_eq!( case1.selection, Some(Expr::BinaryOp { left: Box::new(Expr::CompoundIdentifier(vec![ Ident::new("t1"), Ident::new("c1") ])), op: BinaryOperator::Eq, right: Box::new(Expr::OuterJoin(Box::new(Expr::CompoundIdentifier(vec![ Ident::new("t2"), Ident::new("c2") ])))) }) ); // regular identifiers let case2 = snowflake().verified_only_select("SELECT t1.c1, t2.c2 FROM t1, t2 WHERE c1 = c2 (+)"); assert_eq!( case2.selection, Some(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("c1"))), op: BinaryOperator::Eq, right: Box::new(Expr::OuterJoin(Box::new(Expr::Identifier(Ident::new( "c2" ))))) }) ); // ensure we can still parse function calls with a unary plus arg let case3 = snowflake().verified_only_select("SELECT t1.c1, t2.c2 FROM t1, t2 WHERE c1 = myudf(+42)"); assert_eq!( case3.selection, Some(Expr::BinaryOp { left: Box::new(Expr::Identifier(Ident::new("c1"))), op: BinaryOperator::Eq, right: Box::new(call( "myudf", [Expr::UnaryOp { op: UnaryOperator::Plus, expr: Box::new(Expr::value(number("42"))) }] )), }) ); // permissive with whitespace snowflake().verified_only_select_with_canonical( "SELECT t1.c1, t2.c2 FROM t1, t2 WHERE t1.c1 = t2.c2( + )", "SELECT t1.c1, t2.c2 FROM t1, t2 WHERE t1.c1 = t2.c2 (+)", ); } #[test] fn test_sf_trailing_commas() { snowflake().verified_only_select_with_canonical("SELECT 1, 2, FROM t", "SELECT 1, 2 FROM t"); } #[test] fn test_select_wildcard_with_ilike() { let select = snowflake_and_generic().verified_only_select(r#"SELECT * ILIKE '%id%' FROM tbl"#); let expected = SelectItem::Wildcard(WildcardAdditionalOptions { opt_ilike: Some(IlikeSelectItem { pattern: "%id%".to_owned(), }), ..Default::default() }); assert_eq!(expected, select.projection[0]); } #[test] fn test_select_wildcard_with_ilike_double_quote() { let res = snowflake().parse_sql_statements(r#"SELECT * ILIKE "%id" FROM tbl"#); assert_eq!( res.unwrap_err().to_string(), "sql parser error: Expected: ilike pattern, found: \"%id\"" ); } #[test] fn test_select_wildcard_with_ilike_number() { let res = snowflake().parse_sql_statements(r#"SELECT * ILIKE 42 FROM tbl"#); assert_eq!( res.unwrap_err().to_string(), "sql parser error: Expected: ilike pattern, found: 42" ); } #[test] fn test_select_wildcard_with_ilike_replace() { let res = snowflake().parse_sql_statements(r#"SELECT * ILIKE '%id%' EXCLUDE col FROM tbl"#); assert_eq!( res.unwrap_err().to_string(), "sql parser error: Expected: end of statement, found: EXCLUDE" ); } #[test] fn first_value_ignore_nulls() { snowflake().verified_only_select(concat!( "SELECT FIRST_VALUE(column2 IGNORE NULLS) ", "OVER (PARTITION BY column1 ORDER BY column2) ", "FROM some_table" )); } #[test] fn test_pivot() { // pivot on static list of values with default #[rustfmt::skip] snowflake().verified_only_select(concat!( "SELECT * ", "FROM quarterly_sales ", "PIVOT(SUM(amount) ", "FOR quarter IN (", "'2023_Q1', ", "'2023_Q2', ", "'2023_Q3', ", "'2023_Q4', ", "'2024_Q1') ", "DEFAULT ON NULL (0)", ") ", "ORDER BY empid", )); // dynamic pivot from subquery #[rustfmt::skip] snowflake().verified_only_select(concat!( "SELECT * ", "FROM quarterly_sales ", "PIVOT(SUM(amount) FOR quarter IN (", "SELECT DISTINCT quarter ", "FROM ad_campaign_types_by_quarter ", "WHERE television = true ", "ORDER BY quarter)", ") ", "ORDER BY empid", )); // dynamic pivot on any value (with order by) #[rustfmt::skip] snowflake().verified_only_select(concat!( "SELECT * ", "FROM quarterly_sales ", "PIVOT(SUM(amount) FOR quarter IN (ANY ORDER BY quarter)) ", "ORDER BY empid", )); // dynamic pivot on any value (without order by) #[rustfmt::skip] snowflake().verified_only_select(concat!( "SELECT * ", "FROM sales_data ", "PIVOT(SUM(total_sales) FOR fis_quarter IN (ANY)) ", "WHERE fis_year IN (2023) ", "ORDER BY region", )); } #[test] fn asof_joins() { #[rustfmt::skip] let query = snowflake_and_generic().verified_only_select(concat!( "SELECT * ", "FROM trades_unixtime AS tu ", "ASOF JOIN quotes_unixtime AS qu ", "MATCH_CONDITION (tu.trade_time >= qu.quote_time)", )); assert_eq!( query.from[0], TableWithJoins { relation: table_with_alias("trades_unixtime", true, "tu"), joins: vec![Join { relation: table_with_alias("quotes_unixtime", true, "qu"), global: false, join_operator: JoinOperator::AsOf { match_condition: Expr::BinaryOp { left: Box::new(Expr::CompoundIdentifier(vec![ Ident::new("tu"), Ident::new("trade_time"), ])), op: BinaryOperator::GtEq, right: Box::new(Expr::CompoundIdentifier(vec![ Ident::new("qu"), Ident::new("quote_time"), ])), }, constraint: JoinConstraint::None, }, }], } ); #[rustfmt::skip] snowflake_and_generic().verified_query(concat!( "SELECT t.stock_symbol, t.trade_time, t.quantity, q.quote_time, q.price ", "FROM trades AS t ASOF JOIN quotes AS q ", "MATCH_CONDITION (t.trade_time >= quote_time) ", "ON t.stock_symbol = q.stock_symbol ", "ORDER BY t.stock_symbol", )); #[rustfmt::skip] snowflake_and_generic().verified_query(concat!( "SELECT t.stock_symbol, c.company_name, t.trade_time, t.quantity, q.quote_time, q.price ", "FROM trades AS t ASOF JOIN quotes AS q ", "MATCH_CONDITION (t.trade_time <= quote_time) ", "USING(stock_symbol) ", "JOIN companies AS c ON c.stock_symbol = t.stock_symbol ", "ORDER BY t.stock_symbol", )); #[rustfmt::skip] snowflake_and_generic().verified_query(concat!( "SELECT * ", "FROM snowtime AS s ", "ASOF JOIN raintime AS r ", "MATCH_CONDITION (s.observed >= r.observed) ", "ON s.state = r.state ", "ASOF JOIN preciptime AS p ", "MATCH_CONDITION (s.observed >= p.observed) ", "ON s.state = p.state ", "ORDER BY s.observed", )); // Test without explicit aliases #[rustfmt::skip] snowflake_and_generic().verified_query(concat!( "SELECT * ", "FROM snowtime ", "ASOF JOIN raintime ", "MATCH_CONDITION (snowtime.observed >= raintime.observed) ", "ON snowtime.state = raintime.state ", "ASOF JOIN preciptime ", "MATCH_CONDITION (showtime.observed >= preciptime.observed) ", "ON showtime.state = preciptime.state ", "ORDER BY showtime.observed", )); } #[test] fn test_parse_position() { snowflake().verified_query("SELECT position('an', 'banana', 1)"); snowflake().verified_query("SELECT n, h, POSITION(n IN h) FROM pos"); } #[test] fn explain_describe() { snowflake().verified_stmt("DESCRIBE test.table"); snowflake().verified_stmt("DESCRIBE TABLE test.table"); } #[test] fn explain_desc() { snowflake().verified_stmt("DESC test.table"); snowflake().verified_stmt("DESC TABLE test.table"); } #[test] fn parse_explain_table() { match snowflake().verified_stmt("EXPLAIN TABLE test_identifier") { Statement::ExplainTable { describe_alias, hive_format, has_table_keyword, table_name, } => { assert_eq!(describe_alias, DescribeAlias::Explain); assert_eq!(hive_format, None); assert_eq!(has_table_keyword, true); assert_eq!("test_identifier", table_name.to_string()); } _ => panic!("Unexpected Statement, must be ExplainTable"), } } #[test] fn parse_use() { let valid_object_names = ["mydb", "CATALOG", "DEFAULT"]; let quote_styles = ['\'', '"', '`']; for object_name in &valid_object_names { // Test single identifier without quotes assert_eq!( snowflake().verified_stmt(&format!("USE {object_name}")), Statement::Use(Use::Object(ObjectName::from(vec![Ident::new( object_name.to_string() )]))) ); for "e in "e_styles { // Test single identifier with different type of quotes assert_eq!( snowflake().verified_stmt(&format!("USE {quote}{object_name}{quote}")), Statement::Use(Use::Object(ObjectName::from(vec![Ident::with_quote( quote, object_name.to_string(), )]))) ); } } for "e in "e_styles { // Test double identifier with different type of quotes assert_eq!( snowflake().verified_stmt(&format!( "USE {quote}CATALOG{quote}.{quote}my_schema{quote}" )), Statement::Use(Use::Object(ObjectName::from(vec![ Ident::with_quote(quote, "CATALOG"), Ident::with_quote(quote, "my_schema") ]))) ); } // Test double identifier without quotes assert_eq!( snowflake().verified_stmt("USE mydb.my_schema"), Statement::Use(Use::Object(ObjectName::from(vec![ Ident::new("mydb"), Ident::new("my_schema") ]))) ); for "e in "e_styles { // Test single and double identifier with keyword and different type of quotes assert_eq!( snowflake().verified_stmt(&format!("USE DATABASE {quote}my_database{quote}")), Statement::Use(Use::Database(ObjectName::from(vec![Ident::with_quote( quote, "my_database".to_string(), )]))) ); assert_eq!( snowflake().verified_stmt(&format!("USE SCHEMA {quote}my_schema{quote}")), Statement::Use(Use::Schema(ObjectName::from(vec![Ident::with_quote( quote, "my_schema".to_string(), )]))) ); assert_eq!( snowflake().verified_stmt(&format!( "USE SCHEMA {quote}CATALOG{quote}.{quote}my_schema{quote}" )), Statement::Use(Use::Schema(ObjectName::from(vec![ Ident::with_quote(quote, "CATALOG"), Ident::with_quote(quote, "my_schema") ]))) ); assert_eq!( snowflake().verified_stmt(&format!("USE ROLE {quote}my_role{quote}")), Statement::Use(Use::Role(ObjectName::from(vec![Ident::with_quote( quote, "my_role".to_string(), )]))) ); assert_eq!( snowflake().verified_stmt(&format!("USE WAREHOUSE {quote}my_wh{quote}")), Statement::Use(Use::Warehouse(ObjectName::from(vec![Ident::with_quote( quote, "my_wh".to_string(), )]))) ); } // Test invalid syntax - missing identifier let invalid_cases = ["USE SCHEMA", "USE DATABASE", "USE WAREHOUSE"]; for sql in &invalid_cases { assert_eq!( snowflake().parse_sql_statements(sql).unwrap_err(), ParserError::ParserError("Expected: identifier, found: EOF".to_string()), ); } snowflake().verified_stmt("USE SECONDARY ROLES ALL"); snowflake().verified_stmt("USE SECONDARY ROLES NONE"); snowflake().verified_stmt("USE SECONDARY ROLES r1, r2, r3"); // The following is not documented by Snowflake but still works: snowflake().one_statement_parses_to("USE SECONDARY ROLE ALL", "USE SECONDARY ROLES ALL"); snowflake().one_statement_parses_to("USE SECONDARY ROLE NONE", "USE SECONDARY ROLES NONE"); snowflake().one_statement_parses_to( "USE SECONDARY ROLE r1, r2, r3", "USE SECONDARY ROLES r1, r2, r3", ); } #[test] fn view_comment_option_should_be_after_column_list() { for sql in [ "CREATE OR REPLACE VIEW v (a) COMMENT = 'Comment' AS SELECT a FROM t", "CREATE OR REPLACE VIEW v (a COMMENT 'a comment', b, c COMMENT 'c comment') COMMENT = 'Comment' AS SELECT a FROM t", "CREATE OR REPLACE VIEW v (a COMMENT 'a comment', b, c COMMENT 'c comment') WITH (foo = bar) COMMENT = 'Comment' AS SELECT a FROM t", ] { snowflake() .verified_stmt(sql); } } #[test] fn parse_view_column_descriptions() { let sql = "CREATE OR REPLACE VIEW v (a COMMENT 'Comment', b) AS SELECT a, b FROM table1"; match snowflake().verified_stmt(sql) { Statement::CreateView(CreateView { name, columns, .. }) => { assert_eq!(name.to_string(), "v"); assert_eq!( columns, vec![ ViewColumnDef { name: Ident::new("a"), data_type: None, options: Some(ColumnOptions::SpaceSeparated(vec![ColumnOption::Comment( "Comment".to_string() )])), }, ViewColumnDef { name: Ident::new("b"), data_type: None, options: None, } ] ); } _ => unreachable!(), }; } #[test] fn test_parentheses_overflow() { // Use a modest nesting level to avoid actual stack overflow on // CI runners with small thread stacks (debug builds use large frames // and each nesting level adds extra depth via maybe_parse). let max_nesting_level: usize = 20; // Verify the recursion check is not too wasteful (num of parentheses within budget) let slack = 3; let l_parens = "(".repeat(max_nesting_level - slack); let r_parens = ")".repeat(max_nesting_level - slack); let sql = format!("SELECT * FROM {l_parens}a.b.c{r_parens}"); let parsed = snowflake_with_recursion_limit(max_nesting_level).parse_sql_statements(sql.as_str()); assert_eq!(parsed.err(), None); // Verify the recursion check triggers (one more paren exceeds the budget) let slack = 2; let l_parens = "(".repeat(max_nesting_level - slack); let r_parens = ")".repeat(max_nesting_level - slack); let sql = format!("SELECT * FROM {l_parens}a.b.c{r_parens}"); let parsed = snowflake_with_recursion_limit(max_nesting_level).parse_sql_statements(sql.as_str()); assert_eq!(parsed.err(), Some(ParserError::RecursionLimitExceeded)); } #[test] fn test_show_databases() { snowflake().verified_stmt("SHOW DATABASES"); snowflake().verified_stmt("SHOW TERSE DATABASES"); snowflake().verified_stmt("SHOW DATABASES HISTORY"); snowflake().verified_stmt("SHOW DATABASES LIKE '%abc%'"); snowflake().verified_stmt("SHOW DATABASES STARTS WITH 'demo_db'"); snowflake().verified_stmt("SHOW DATABASES LIMIT 12"); snowflake() .verified_stmt("SHOW DATABASES HISTORY LIKE '%aa' STARTS WITH 'demo' LIMIT 20 FROM 'abc'"); snowflake().verified_stmt("SHOW DATABASES IN ACCOUNT abc"); } #[test] fn test_parse_show_schemas() { snowflake().verified_stmt("SHOW SCHEMAS"); snowflake().verified_stmt("SHOW TERSE SCHEMAS"); snowflake().verified_stmt("SHOW SCHEMAS IN ACCOUNT"); snowflake().verified_stmt("SHOW SCHEMAS IN ACCOUNT abc"); snowflake().verified_stmt("SHOW SCHEMAS IN DATABASE"); snowflake().verified_stmt("SHOW SCHEMAS IN DATABASE xyz"); snowflake().verified_stmt("SHOW SCHEMAS HISTORY LIKE '%xa%'"); snowflake().verified_stmt("SHOW SCHEMAS STARTS WITH 'abc' LIMIT 20"); snowflake().verified_stmt("SHOW SCHEMAS IN DATABASE STARTS WITH 'abc' LIMIT 20 FROM 'xyz'"); } #[test] fn test_parse_show_objects() { snowflake().verified_stmt("SHOW OBJECTS"); snowflake().verified_stmt("SHOW OBJECTS IN abc"); snowflake().verified_stmt("SHOW OBJECTS LIKE '%test%' IN abc"); snowflake().verified_stmt("SHOW OBJECTS IN ACCOUNT"); snowflake().verified_stmt("SHOW OBJECTS IN DATABASE"); snowflake().verified_stmt("SHOW OBJECTS IN DATABASE abc"); snowflake().verified_stmt("SHOW OBJECTS IN SCHEMA"); snowflake().verified_stmt("SHOW OBJECTS IN SCHEMA abc"); snowflake().verified_stmt("SHOW TERSE OBJECTS"); snowflake().verified_stmt("SHOW TERSE OBJECTS IN abc"); snowflake().verified_stmt("SHOW TERSE OBJECTS LIKE '%test%' IN abc"); snowflake().verified_stmt("SHOW TERSE OBJECTS LIKE '%test%' IN abc STARTS WITH 'b'"); snowflake().verified_stmt("SHOW TERSE OBJECTS LIKE '%test%' IN abc STARTS WITH 'b' LIMIT 10"); snowflake() .verified_stmt("SHOW TERSE OBJECTS LIKE '%test%' IN abc STARTS WITH 'b' LIMIT 10 FROM 'x'"); match snowflake().verified_stmt("SHOW TERSE OBJECTS LIKE '%test%' IN abc") { Statement::ShowObjects(ShowObjects { terse, show_options, }) => { assert!(terse); let name = match show_options.show_in { Some(ShowStatementIn { parent_name: Some(val), .. }) => val.to_string(), _ => unreachable!(), }; assert_eq!("abc", name); let like = match show_options.filter_position { Some(ShowStatementFilterPosition::Infix(ShowStatementFilter::Like(val))) => val, _ => unreachable!(), }; assert_eq!("%test%", like); } _ => unreachable!(), } } #[test] fn test_parse_show_tables() { snowflake().verified_stmt("SHOW TABLES"); snowflake().verified_stmt("SHOW TERSE TABLES"); snowflake().verified_stmt("SHOW TABLES IN ACCOUNT"); snowflake().verified_stmt("SHOW TABLES IN DATABASE"); snowflake().verified_stmt("SHOW TABLES IN DATABASE xyz"); snowflake().verified_stmt("SHOW TABLES IN SCHEMA"); snowflake().verified_stmt("SHOW TABLES IN SCHEMA xyz"); snowflake().verified_stmt("SHOW TABLES HISTORY LIKE '%xa%'"); snowflake().verified_stmt("SHOW TABLES STARTS WITH 'abc' LIMIT 20"); snowflake().verified_stmt("SHOW TABLES IN SCHEMA STARTS WITH 'abc' LIMIT 20 FROM 'xyz'"); snowflake().verified_stmt("SHOW EXTERNAL TABLES"); snowflake().verified_stmt("SHOW EXTERNAL TABLES IN ACCOUNT"); snowflake().verified_stmt("SHOW EXTERNAL TABLES IN DATABASE"); snowflake().verified_stmt("SHOW EXTERNAL TABLES IN DATABASE xyz"); snowflake().verified_stmt("SHOW EXTERNAL TABLES IN SCHEMA"); snowflake().verified_stmt("SHOW EXTERNAL TABLES IN SCHEMA xyz"); snowflake().verified_stmt("SHOW EXTERNAL TABLES STARTS WITH 'abc' LIMIT 20"); snowflake() .verified_stmt("SHOW EXTERNAL TABLES IN SCHEMA STARTS WITH 'abc' LIMIT 20 FROM 'xyz'"); } #[test] fn test_show_views() { snowflake().verified_stmt("SHOW VIEWS"); snowflake().verified_stmt("SHOW TERSE VIEWS"); snowflake().verified_stmt("SHOW VIEWS IN ACCOUNT"); snowflake().verified_stmt("SHOW VIEWS IN DATABASE"); snowflake().verified_stmt("SHOW VIEWS IN DATABASE xyz"); snowflake().verified_stmt("SHOW VIEWS IN SCHEMA"); snowflake().verified_stmt("SHOW VIEWS IN SCHEMA xyz"); snowflake().verified_stmt("SHOW VIEWS STARTS WITH 'abc' LIMIT 20"); snowflake().verified_stmt("SHOW VIEWS IN SCHEMA STARTS WITH 'abc' LIMIT 20 FROM 'xyz'"); } #[test] fn test_parse_show_columns_sql() { snowflake().verified_stmt("SHOW COLUMNS IN TABLE"); snowflake().verified_stmt("SHOW COLUMNS IN TABLE abc"); snowflake().verified_stmt("SHOW COLUMNS LIKE '%xyz%' IN TABLE abc"); } #[test] fn test_projection_with_nested_trailing_commas() { let sql = "SELECT a, FROM b, LATERAL FLATTEN(input => events)"; let _ = snowflake().parse_sql_statements(sql).unwrap(); //Single nesting let sql = "SELECT (SELECT a, FROM b, LATERAL FLATTEN(input => events))"; let _ = snowflake().parse_sql_statements(sql).unwrap(); //Double nesting let sql = "SELECT (SELECT (SELECT a, FROM b, LATERAL FLATTEN(input => events)))"; let _ = snowflake().parse_sql_statements(sql).unwrap(); let sql = "SELECT a, b, FROM c, (SELECT d, e, FROM f, LATERAL FLATTEN(input => events))"; let _ = snowflake().parse_sql_statements(sql).unwrap(); } #[test] fn test_sf_double_dot_notation() { snowflake().verified_stmt("SELECT * FROM db_name..table_name"); snowflake().verified_stmt("SELECT * FROM x, y..z JOIN a..b AS b ON x.id = b.id"); assert_eq!( snowflake() .parse_sql_statements("SELECT * FROM X.Y..") .unwrap_err() .to_string(), "sql parser error: Expected: identifier, found: ." ); assert_eq!( snowflake() .parse_sql_statements("SELECT * FROM X..Y..Z") .unwrap_err() .to_string(), "sql parser error: Expected: identifier, found: ." ); assert_eq!( // Ensure we don't parse leading token snowflake() .parse_sql_statements("SELECT * FROM .X.Y") .unwrap_err() .to_string(), "sql parser error: Expected: identifier, found: ." ); } #[test] fn test_parse_double_dot_notation_wrong_position() {} #[test] fn parse_insert_overwrite() { let insert_overwrite_into = r#"INSERT OVERWRITE INTO schema.table SELECT a FROM b"#; snowflake().verified_stmt(insert_overwrite_into); } #[test] fn test_table_sample() { snowflake_and_generic().verified_stmt("SELECT * FROM testtable SAMPLE (10)"); snowflake_and_generic().verified_stmt("SELECT * FROM testtable TABLESAMPLE (10)"); snowflake_and_generic() .verified_stmt("SELECT * FROM testtable AS t TABLESAMPLE BERNOULLI (10)"); snowflake_and_generic().verified_stmt("SELECT * FROM testtable AS t TABLESAMPLE ROW (10)"); snowflake_and_generic().verified_stmt("SELECT * FROM testtable AS t TABLESAMPLE ROW (10 ROWS)"); snowflake_and_generic() .verified_stmt("SELECT * FROM testtable TABLESAMPLE BLOCK (3) SEED (82)"); snowflake_and_generic() .verified_stmt("SELECT * FROM testtable TABLESAMPLE SYSTEM (3) REPEATABLE (82)"); snowflake_and_generic().verified_stmt("SELECT id FROM mytable TABLESAMPLE (10) REPEATABLE (1)"); snowflake_and_generic().verified_stmt("SELECT id FROM mytable TABLESAMPLE (10) SEED (1)"); } #[test] fn test_subquery_sample() { // Test SAMPLE clause on subqueries (derived tables) snowflake_and_generic().verified_stmt("SELECT * FROM (SELECT * FROM mytable) SAMPLE (10)"); snowflake_and_generic() .verified_stmt("SELECT * FROM (SELECT * FROM mytable) SAMPLE (10000 ROWS)"); snowflake_and_generic() .verified_stmt("SELECT * FROM (SELECT * FROM mytable) AS t SAMPLE (50 PERCENT)"); // Nested subquery with SAMPLE snowflake_and_generic().verified_stmt( "SELECT * FROM (SELECT * FROM (SELECT report_from FROM mytable) SAMPLE (10000 ROWS)) AS anon_1", ); // SAMPLE with SEED on subquery snowflake_and_generic() .verified_stmt("SELECT * FROM (SELECT * FROM mytable) SAMPLE (10) SEED (42)"); } #[test] fn test_multi_table_insert_unconditional() { // Basic unconditional multi-table insert // See: https://docs.snowflake.com/en/sql-reference/sql/insert-multi-table snowflake().verified_stmt("INSERT ALL INTO t1 SELECT n1, n2, n3 FROM src"); // Multiple INTO clauses snowflake().verified_stmt("INSERT ALL INTO t1 INTO t2 SELECT n1, n2, n3 FROM src"); // With column list snowflake().verified_stmt("INSERT ALL INTO t1 (c1, c2, c3) SELECT n1, n2, n3 FROM src"); // With VALUES clause snowflake().verified_stmt( "INSERT ALL INTO t1 (c1, c2, c3) VALUES (n2, n1, DEFAULT) SELECT n1, n2, n3 FROM src", ); // Complex example from Snowflake docs snowflake().verified_stmt( "INSERT ALL INTO t1 INTO t1 (c1, c2, c3) VALUES (n2, n1, DEFAULT) INTO t2 (c1, c2, c3) INTO t2 VALUES (n3, n2, n1) SELECT n1, n2, n3 FROM src" ); // With OVERWRITE snowflake().verified_stmt("INSERT OVERWRITE ALL INTO t1 INTO t2 SELECT n1, n2, n3 FROM src"); } #[test] fn test_multi_table_insert_conditional() { // Basic conditional multi-table insert with WHEN clause // See: https://docs.snowflake.com/en/sql-reference/sql/insert-multi-table snowflake().verified_stmt("INSERT ALL WHEN n1 > 100 THEN INTO t1 SELECT n1 FROM src"); // Multiple WHEN clauses snowflake().verified_stmt( "INSERT ALL WHEN n1 > 100 THEN INTO t1 WHEN n1 > 10 THEN INTO t2 SELECT n1 FROM src", ); // WHEN with multiple INTO clauses snowflake().verified_stmt("INSERT ALL WHEN n1 > 10 THEN INTO t1 INTO t2 SELECT n1 FROM src"); // With ELSE clause snowflake() .verified_stmt("INSERT ALL WHEN n1 > 100 THEN INTO t1 ELSE INTO t2 SELECT n1 FROM src"); // Complex conditional insert from Snowflake docs snowflake().verified_stmt( "INSERT ALL WHEN n1 > 100 THEN INTO t1 WHEN n1 > 10 THEN INTO t1 INTO t2 ELSE INTO t2 SELECT n1 FROM src" ); // INSERT FIRST - only first matching WHEN clause executes snowflake().verified_stmt( "INSERT FIRST WHEN n1 > 100 THEN INTO t1 WHEN n1 > 10 THEN INTO t1 INTO t2 ELSE INTO t2 SELECT n1 FROM src" ); // With OVERWRITE snowflake().verified_stmt( "INSERT OVERWRITE ALL WHEN n1 > 100 THEN INTO t1 ELSE INTO t2 SELECT n1 FROM src", ); // WHEN with always-true condition snowflake().verified_stmt("INSERT ALL WHEN 1 = 1 THEN INTO t1 SELECT n1 FROM src"); } #[test] fn test_multi_table_insert_with_values() { // INTO clause with VALUES using column references snowflake().verified_stmt("INSERT ALL INTO t1 VALUES (n1, n2) SELECT n1, n2 FROM src"); // INTO clause with VALUES using DEFAULT snowflake().verified_stmt( "INSERT ALL INTO t1 (c1, c2, c3) VALUES (n1, n2, DEFAULT) SELECT n1, n2 FROM src", ); // INTO clause with VALUES using NULL snowflake().verified_stmt( "INSERT ALL INTO t1 (c1, c2, c3) VALUES (n1, NULL, n2) SELECT n1, n2 FROM src", ); // Positional alias in VALUES snowflake().verified_stmt("INSERT ALL INTO t1 VALUES ($1, $2) SELECT 1, 50 AS an_alias"); } /// Unit tests for multi-table INSERT AST structure validation #[test] fn test_multi_table_insert_ast_unconditional() { // Test basic unconditional multi-table insert AST let sql = "INSERT ALL INTO t1 INTO t2 (c1, c2) SELECT n1, n2 FROM src"; let stmt = snowflake().verified_stmt(sql); match stmt { Statement::Insert(Insert { multi_table_insert_type, overwrite, multi_table_into_clauses, multi_table_when_clauses, multi_table_else_clause, source, .. }) => { // Should be INSERT ALL (not FIRST) assert_eq!(multi_table_insert_type, Some(MultiTableInsertType::All)); assert!(!overwrite); // Should have 2 INTO clauses assert_eq!(multi_table_into_clauses.len(), 2); // First INTO clause: INTO t1 assert_eq!(multi_table_into_clauses[0].table_name.to_string(), "t1"); assert!(multi_table_into_clauses[0].columns.is_empty()); assert!(multi_table_into_clauses[0].values.is_none()); // Second INTO clause: INTO t2 (c1, c2) assert_eq!(multi_table_into_clauses[1].table_name.to_string(), "t2"); assert_eq!(multi_table_into_clauses[1].columns.len(), 2); assert_eq!(multi_table_into_clauses[1].columns[0].to_string(), "c1"); assert_eq!(multi_table_into_clauses[1].columns[1].to_string(), "c2"); assert!(multi_table_into_clauses[1].values.is_none()); // No WHEN clauses for unconditional insert assert!(multi_table_when_clauses.is_empty()); assert!(multi_table_else_clause.is_none()); // Should have source query assert!(source.is_some()); } _ => panic!("Expected INSERT statement"), } } #[test] fn test_multi_table_insert_ast_with_values() { // Test INTO clause with VALUES let sql = "INSERT ALL INTO t1 (c1, c2, c3) VALUES (n1, n2, DEFAULT) SELECT n1, n2 FROM src"; let stmt = snowflake().verified_stmt(sql); match stmt { Statement::Insert(Insert { multi_table_into_clauses, .. }) => { assert_eq!(multi_table_into_clauses.len(), 1); let into_clause = &multi_table_into_clauses[0]; assert_eq!(into_clause.table_name.to_string(), "t1"); assert_eq!(into_clause.columns.len(), 3); // Check VALUES clause let values = into_clause.values.as_ref().expect("Expected VALUES clause"); assert_eq!(values.values.len(), 3); // First value: n1 (expression) match &values.values[0] { MultiTableInsertValue::Expr(expr) => { assert_eq!(expr.to_string(), "n1"); } _ => panic!("Expected Expr"), } // Second value: n2 (expression) match &values.values[1] { MultiTableInsertValue::Expr(expr) => { assert_eq!(expr.to_string(), "n2"); } _ => panic!("Expected Expr"), } // Third value: DEFAULT match &values.values[2] { MultiTableInsertValue::Default => {} _ => panic!("Expected DEFAULT"), } } _ => panic!("Expected INSERT statement"), } } #[test] fn test_multi_table_insert_ast_conditional() { // Test conditional multi-table insert with WHEN clauses let sql = "INSERT ALL WHEN n1 > 100 THEN INTO t1 WHEN n1 > 10 THEN INTO t2 INTO t3 ELSE INTO t4 SELECT n1 FROM src"; let stmt = snowflake().verified_stmt(sql); match stmt { Statement::Insert(Insert { multi_table_insert_type, multi_table_into_clauses, multi_table_when_clauses, multi_table_else_clause, .. }) => { // Should be INSERT ALL (not FIRST) assert_eq!(multi_table_insert_type, Some(MultiTableInsertType::All)); // Unconditional INTO clauses should be empty for conditional insert assert!(multi_table_into_clauses.is_empty()); // Should have 2 WHEN clauses assert_eq!(multi_table_when_clauses.len(), 2); // First WHEN clause: WHEN n1 > 100 THEN INTO t1 assert_eq!( multi_table_when_clauses[0].condition.to_string(), "n1 > 100" ); assert_eq!(multi_table_when_clauses[0].into_clauses.len(), 1); assert_eq!( multi_table_when_clauses[0].into_clauses[0] .table_name .to_string(), "t1" ); // Second WHEN clause: WHEN n1 > 10 THEN INTO t2 INTO t3 assert_eq!(multi_table_when_clauses[1].condition.to_string(), "n1 > 10"); assert_eq!(multi_table_when_clauses[1].into_clauses.len(), 2); assert_eq!( multi_table_when_clauses[1].into_clauses[0] .table_name .to_string(), "t2" ); assert_eq!( multi_table_when_clauses[1].into_clauses[1] .table_name .to_string(), "t3" ); // ELSE clause: ELSE INTO t4 let else_clause = multi_table_else_clause.expect("Expected ELSE clause"); assert_eq!(else_clause.len(), 1); assert_eq!(else_clause[0].table_name.to_string(), "t4"); } _ => panic!("Expected INSERT statement"), } } #[test] fn test_multi_table_insert_ast_first() { // Test INSERT FIRST vs INSERT ALL let sql = "INSERT FIRST WHEN n1 > 100 THEN INTO t1 WHEN n1 > 10 THEN INTO t2 SELECT n1 FROM src"; let stmt = snowflake().verified_stmt(sql); match stmt { Statement::Insert(Insert { multi_table_insert_type, multi_table_when_clauses, .. }) => { // Should be INSERT FIRST assert_eq!(multi_table_insert_type, Some(MultiTableInsertType::First)); assert_eq!(multi_table_when_clauses.len(), 2); } _ => panic!("Expected INSERT statement"), } } #[test] fn test_multi_table_insert_ast_overwrite() { // Test INSERT OVERWRITE ALL let sql = "INSERT OVERWRITE ALL INTO t1 INTO t2 SELECT n1 FROM src"; let stmt = snowflake().verified_stmt(sql); match stmt { Statement::Insert(Insert { overwrite, multi_table_insert_type, multi_table_into_clauses, .. }) => { assert!(overwrite); assert_eq!(multi_table_insert_type, Some(MultiTableInsertType::All)); assert_eq!(multi_table_into_clauses.len(), 2); } _ => panic!("Expected INSERT statement"), } } #[test] fn test_multi_table_insert_ast_complex_values() { // Test complex VALUES with expressions let sql = "INSERT ALL INTO t1 VALUES (n1 + n2, n3 * 2, DEFAULT) SELECT n1, n2, n3 FROM src"; let stmt = snowflake().verified_stmt(sql); match stmt { Statement::Insert(Insert { multi_table_into_clauses, .. }) => { assert_eq!(multi_table_into_clauses.len(), 1); let values = multi_table_into_clauses[0] .values .as_ref() .expect("Expected VALUES"); assert_eq!(values.values.len(), 3); // First value: n1 + n2 (binary expression) match &values.values[0] { MultiTableInsertValue::Expr(Expr::BinaryOp { op, .. }) => { assert_eq!(*op, BinaryOperator::Plus); } _ => panic!("Expected BinaryOp expression"), } // Second value: n3 * 2 (binary expression) match &values.values[1] { MultiTableInsertValue::Expr(Expr::BinaryOp { op, .. }) => { assert_eq!(*op, BinaryOperator::Multiply); } _ => panic!("Expected BinaryOp expression"), } // Third value: DEFAULT assert!(matches!(&values.values[2], MultiTableInsertValue::Default)); } _ => panic!("Expected INSERT statement"), } } #[test] fn parse_ls_and_rm() { snowflake().one_statement_parses_to("LS @~", "LIST @~"); snowflake().one_statement_parses_to("RM @~", "REMOVE @~"); let statement = snowflake() .verified_stmt("LIST @SNOWFLAKE_KAFKA_CONNECTOR_externalDataLakeSnowflakeConnector_STAGE_call_tracker_stream/"); match statement { Statement::List(command) => { assert_eq!(command.stage, ObjectName::from(vec!["@SNOWFLAKE_KAFKA_CONNECTOR_externalDataLakeSnowflakeConnector_STAGE_call_tracker_stream/".into()])); assert!(command.pattern.is_none()); } _ => unreachable!(), }; let statement = snowflake().verified_stmt("REMOVE @my_csv_stage/analysis/ PATTERN='.*data_0.*'"); match statement { Statement::Remove(command) => { assert_eq!( command.stage, ObjectName::from(vec!["@my_csv_stage/analysis/".into()]) ); assert_eq!(command.pattern, Some(".*data_0.*".to_string())); } _ => unreachable!(), }; snowflake().verified_stmt(r#"LIST @"STAGE_WITH_QUOTES""#); // Semi-colon after stage name - should terminate the stage name snowflake() .parse_sql_statements("LIST @db1.schema1.stage1/dir1/;") .unwrap(); } #[test] fn test_sql_keywords_as_select_item_ident() { // Some keywords that should be parsed as an alias let unreserved_kws = vec!["CLUSTER", "FETCH", "RETURNING", "LIMIT", "EXCEPT", "SORT"]; for kw in unreserved_kws { snowflake().verified_stmt(&format!("SELECT 1, {kw}")); } // Some keywords that should not be parsed as an alias let reserved_kws = vec![ "FROM", "GROUP", "HAVING", "INTERSECT", "INTO", "ORDER", "SELECT", "UNION", "WHERE", "WITH", ]; for kw in reserved_kws { assert!(snowflake() .parse_sql_statements(&format!("SELECT 1, {kw}")) .is_err()); } } #[test] fn test_sql_keywords_as_select_item_aliases() { // Some keywords that should be parsed as an alias let unreserved_kws = vec!["CLUSTER", "FETCH", "RETURNING", "LIMIT", "EXCEPT", "SORT"]; for kw in unreserved_kws { snowflake() .one_statement_parses_to(&format!("SELECT 1 {kw}"), &format!("SELECT 1 AS {kw}")); } // Some keywords that should not be parsed as an alias let reserved_kws = vec![ "FROM", "GROUP", "HAVING", "INTERSECT", "INTO", "ORDER", "SELECT", "UNION", "WHERE", "WITH", ]; for kw in reserved_kws { assert!(snowflake() .parse_sql_statements(&format!("SELECT 1 {kw}")) .is_err()); } // LIMIT is alias snowflake().one_statement_parses_to("SELECT 1 LIMIT", "SELECT 1 AS LIMIT"); // LIMIT is not an alias snowflake().verified_stmt("SELECT 1 LIMIT 1"); snowflake().verified_stmt("SELECT 1 LIMIT $1"); snowflake().verified_stmt("SELECT 1 LIMIT ''"); snowflake().verified_stmt("SELECT 1 LIMIT NULL"); snowflake().verified_stmt("SELECT 1 LIMIT $$$$"); } #[test] fn test_sql_keywords_as_table_aliases() { // Some keywords that should be parsed as an alias implicitly let unreserved_kws = vec![ "VIEW", "EXPLAIN", "ANALYZE", "SORT", "PIVOT", "UNPIVOT", "TOP", "LIMIT", "OFFSET", "FETCH", "EXCEPT", "CLUSTER", "DISTRIBUTE", "GLOBAL", "ANTI", "SEMI", "RETURNING", "OUTER", "WINDOW", "END", "PARTITION", "PREWHERE", "SETTINGS", "FORMAT", "MATCH_RECOGNIZE", "OPEN", ]; fn assert_implicit_alias(mut select: Select, canonical_with_explicit_alias: &str) { if let TableFactor::Table { alias, .. } = &mut select .from .get_mut(0) .as_mut() .expect("missing FROM") .relation { let alias = alias.as_mut().expect("missing ALIAS"); assert!(!alias.explicit); alias.explicit = true; assert_eq!(&format!("{select}"), canonical_with_explicit_alias); } else { panic!("unexpected FROM "); } } fn assert_no_alias(select: Select) { if let TableFactor::Table { alias, .. } = &select.from.first().expect("missing FROM").relation { assert_eq!(alias, &None); } else { panic!("unexpected FROM "); } } for kw in unreserved_kws { snowflake().verified_stmt(&format!("SELECT * FROM tbl AS {kw}")); assert_implicit_alias( snowflake().verified_only_select(&format!("SELECT * FROM tbl {kw}")), &format!("SELECT * FROM tbl AS {kw}"), ); } // Some keywords that should not be parsed as an alias implicitly let reserved_kws = vec![ "FROM", "GROUP", "HAVING", "ORDER", "SELECT", "UNION", "WHERE", "WITH", ]; for kw in reserved_kws { assert!(snowflake() .parse_sql_statements(&format!("SELECT * FROM tbl {kw}")) .is_err()); } // LIMIT is alias assert_implicit_alias( snowflake().verified_only_select("SELECT * FROM tbl LIMIT"), "SELECT * FROM tbl AS LIMIT", ); // LIMIT is not an alias assert_no_alias(snowflake().verified_only_select("SELECT * FROM tbl LIMIT 1")); assert_no_alias(snowflake().verified_only_select("SELECT * FROM tbl LIMIT $1")); assert_no_alias(snowflake().verified_only_select("SELECT * FROM tbl LIMIT ''")); assert_no_alias(snowflake().verified_only_select("SELECT * FROM tbl LIMIT NULL")); assert_no_alias(snowflake().verified_only_select("SELECT * FROM tbl LIMIT $$$$")); } #[test] fn test_sql_keywords_as_table_factor() { // LIMIT is a table factor, Snowflake does not reserve it snowflake().verified_stmt("SELECT * FROM tbl, LIMIT"); // LIMIT is not a table factor snowflake().one_statement_parses_to("SELECT * FROM tbl, LIMIT 1", "SELECT * FROM tbl LIMIT 1"); // Table functions are table factors snowflake().verified_stmt("SELECT 1 FROM TABLE(GENERATOR(ROWCOUNT => 10)) AS a, TABLE(GENERATOR(ROWCOUNT => 10)) AS b"); // ORDER is reserved assert!(snowflake() .parse_sql_statements("SELECT * FROM tbl, order") .is_err()); } #[test] fn test_timetravel_at_before() { snowflake().verified_only_select("SELECT * FROM tbl AT(TIMESTAMP => '2024-12-15 00:00:00')"); snowflake() .verified_only_select("SELECT * FROM tbl BEFORE(TIMESTAMP => '2024-12-15 00:00:00')"); } #[test] fn test_changes_clause() { // CHANGES with AT and END snowflake().verified_stmt( r#"SELECT a FROM "PCH_ODS_FIDELIO"."SRC_VW_SYS_ACC_MASTER" CHANGES(INFORMATION => DEFAULT) AT(TIMESTAMP => TO_TIMESTAMP_TZ('2026-02-18 11:23:19.660000000')) END(TIMESTAMP => TO_TIMESTAMP_TZ('2026-02-18 11:38:30.211000000'))"#, ); // CHANGES with AT only (no END) snowflake().verified_stmt( "SELECT a FROM t CHANGES(INFORMATION => DEFAULT) AT(TIMESTAMP => TO_TIMESTAMP_TZ('2026-02-18 11:23:19.660000000'))", ); // CHANGES with APPEND_ONLY snowflake().verified_stmt( "SELECT a FROM t CHANGES(INFORMATION => APPEND_ONLY) AT(TIMESTAMP => TO_TIMESTAMP_TZ('2026-01-01 00:00:00'))", ); // CHANGES with OFFSET snowflake().verified_stmt("SELECT a FROM t CHANGES(INFORMATION => DEFAULT) AT(OFFSET => -60)"); // CHANGES with STATEMENT snowflake().verified_stmt( "SELECT a FROM t CHANGES(INFORMATION => DEFAULT) AT(STATEMENT => '8e5d0ca9-005e-44e6-b858-a8f5b37c5726')", ); } #[test] fn test_grant_account_global_privileges() { let privileges = vec![ "ALL", "ALL PRIVILEGES", "ATTACH POLICY", "AUDIT", "BIND SERVICE ENDPOINT", "IMPORT SHARE", "OVERRIDE SHARE RESTRICTIONS", "PURCHASE DATA EXCHANGE LISTING", "RESOLVE ALL", "READ SESSION", ]; let with_grant_options = vec!["", " WITH GRANT OPTION"]; for p in &privileges { for wgo in &with_grant_options { let sql = format!("GRANT {p} ON ACCOUNT TO ROLE role1{wgo}"); snowflake_and_generic().verified_stmt(&sql); } } let create_object_types = vec![ "ACCOUNT", "APPLICATION", "APPLICATION PACKAGE", "COMPUTE POOL", "DATA EXCHANGE LISTING", "DATABASE", "EXTERNAL VOLUME", "FAILOVER GROUP", "INTEGRATION", "NETWORK POLICY", "ORGANIZATION LISTING", "REPLICATION GROUP", "ROLE", "SHARE", "USER", "WAREHOUSE", ]; for t in &create_object_types { for wgo in &with_grant_options { let sql = format!("GRANT CREATE {t} ON ACCOUNT TO ROLE role1{wgo}"); snowflake_and_generic().verified_stmt(&sql); } } let apply_types = vec![ "AGGREGATION POLICY", "AUTHENTICATION POLICY", "JOIN POLICY", "MASKING POLICY", "PACKAGES POLICY", "PASSWORD POLICY", "PROJECTION POLICY", "ROW ACCESS POLICY", "SESSION POLICY", "TAG", ]; for t in &apply_types { for wgo in &with_grant_options { let sql = format!("GRANT APPLY {t} ON ACCOUNT TO ROLE role1{wgo}"); snowflake_and_generic().verified_stmt(&sql); } } let execute_types = vec![ "ALERT", "DATA METRIC FUNCTION", "MANAGED ALERT", "MANAGED TASK", "TASK", ]; for t in &execute_types { for wgo in &with_grant_options { let sql = format!("GRANT EXECUTE {t} ON ACCOUNT TO ROLE role1{wgo}"); snowflake_and_generic().verified_stmt(&sql); } } let manage_types = vec![ "ACCOUNT SUPPORT CASES", "EVENT SHARING", "GRANTS", "LISTING AUTO FULFILLMENT", "ORGANIZATION SUPPORT CASES", "USER SUPPORT CASES", "WAREHOUSES", ]; for t in &manage_types { for wgo in &with_grant_options { let sql = format!("GRANT MANAGE {t} ON ACCOUNT TO ROLE role1{wgo}"); snowflake_and_generic().verified_stmt(&sql); } } let monitor_types = vec!["EXECUTION", "SECURITY", "USAGE"]; for t in &monitor_types { for wgo in &with_grant_options { let sql = format!("GRANT MONITOR {t} ON ACCOUNT TO ROLE role1{wgo}"); snowflake_and_generic().verified_stmt(&sql); } } } #[test] fn test_grant_account_object_privileges() { let privileges = vec![ "ALL", "ALL PRIVILEGES", "APPLYBUDGET", "MODIFY", "MONITOR", "USAGE", "OPERATE", ]; let objects_types = vec![ "USER", "RESOURCE MONITOR", "WAREHOUSE", "COMPUTE POOL", "DATABASE", "INTEGRATION", "CONNECTION", "FAILOVER GROUP", "REPLICATION GROUP", "EXTERNAL VOLUME", ]; let with_grant_options = vec!["", " WITH GRANT OPTION"]; for t in &objects_types { for p in &privileges { for wgo in &with_grant_options { let sql = format!("GRANT {p} ON {t} obj1 TO ROLE role1{wgo}"); snowflake_and_generic().verified_stmt(&sql); } } } } #[test] fn test_grant_role_to() { snowflake_and_generic().verified_stmt("GRANT ROLE r1 TO ROLE r2"); snowflake_and_generic().verified_stmt("GRANT ROLE r1 TO USER u1"); } #[test] fn test_grant_database_role_to() { snowflake_and_generic().verified_stmt("GRANT DATABASE ROLE r1 TO ROLE r2"); snowflake_and_generic().verified_stmt("GRANT DATABASE ROLE db1.sc1.r1 TO ROLE db1.sc1.r2"); } #[test] fn test_alter_session() { assert_eq!( snowflake() .parse_sql_statements("ALTER SESSION SET") .unwrap_err() .to_string(), "sql parser error: expected at least one option" ); assert_eq!( snowflake() .parse_sql_statements("ALTER SESSION UNSET") .unwrap_err() .to_string(), "sql parser error: expected at least one option" ); snowflake().one_statement_parses_to( "ALTER SESSION SET AUTOCOMMIT=TRUE", "ALTER SESSION SET AUTOCOMMIT=true", ); snowflake().verified_stmt("ALTER SESSION SET AUTOCOMMIT=false QUERY_TAG='tag'"); snowflake().verified_stmt("ALTER SESSION UNSET AUTOCOMMIT"); snowflake().verified_stmt("ALTER SESSION UNSET AUTOCOMMIT, QUERY_TAG"); snowflake().one_statement_parses_to( "ALTER SESSION SET A=false, B='tag';", "ALTER SESSION SET A=false B='tag'", ); snowflake().one_statement_parses_to( "ALTER SESSION SET A=true \nB='tag'", "ALTER SESSION SET A=true B='tag'", ); snowflake().one_statement_parses_to("ALTER SESSION UNSET a\nB", "ALTER SESSION UNSET a, B"); } #[test] fn test_alter_session_followed_by_statement() { let stmts = snowflake() .parse_sql_statements("ALTER SESSION SET QUERY_TAG='hello'; SELECT 42") .unwrap(); match stmts[..] { [Statement::AlterSession { .. }, Statement::Query { .. }] => {} _ => panic!("Unexpected statements: {stmts:?}"), } } #[test] fn test_nested_join_without_parentheses() { let query = "SELECT DISTINCT p.product_id FROM orders AS o INNER JOIN customers AS c INNER JOIN products AS p ON p.customer_id = c.customer_id ON c.order_id = o.order_id"; assert_eq!( only( snowflake() .verified_only_select_with_canonical(query, "SELECT DISTINCT p.product_id FROM orders AS o INNER JOIN (customers AS c INNER JOIN products AS p ON p.customer_id = c.customer_id) ON c.order_id = o.order_id") .from ) .joins, vec![Join { relation: TableFactor::NestedJoin { table_with_joins: Box::new(TableWithJoins { relation: TableFactor::Table { name: ObjectName::from(vec![Ident::new("customers".to_string())]), alias: table_alias(true, "c"), args: None, with_hints: vec![], version: None, partitions: vec![], with_ordinality: false, json_path: None, sample: None, index_hints: vec![], }, joins: vec![Join { relation: TableFactor::Table { name: ObjectName::from(vec![Ident::new("products".to_string())]), alias: table_alias(true, "p"), args: None, with_hints: vec![], version: None, partitions: vec![], with_ordinality: false, json_path: None, sample: None, index_hints: vec![], }, global: false, join_operator: JoinOperator::Inner(JoinConstraint::On(Expr::BinaryOp { left: Box::new(Expr::CompoundIdentifier(vec![ Ident::new("p".to_string()), Ident::new("customer_id".to_string()) ])), op: BinaryOperator::Eq, right: Box::new(Expr::CompoundIdentifier(vec![ Ident::new("c".to_string()), Ident::new("customer_id".to_string()) ])), })), }] }), alias: None }, global: false, join_operator: JoinOperator::Inner(JoinConstraint::On(Expr::BinaryOp { left: Box::new(Expr::CompoundIdentifier(vec![ Ident::new("c".to_string()), Ident::new("order_id".to_string()) ])), op: BinaryOperator::Eq, right: Box::new(Expr::CompoundIdentifier(vec![ Ident::new("o".to_string()), Ident::new("order_id".to_string()) ])), })) }], ); let query = "SELECT DISTINCT p.product_id FROM orders AS o JOIN customers AS c JOIN products AS p ON p.customer_id = c.customer_id ON c.order_id = o.order_id"; assert_eq!( only( snowflake() .verified_only_select_with_canonical(query, "SELECT DISTINCT p.product_id FROM orders AS o JOIN (customers AS c JOIN products AS p ON p.customer_id = c.customer_id) ON c.order_id = o.order_id") .from ) .joins, vec![Join { relation: TableFactor::NestedJoin { table_with_joins: Box::new(TableWithJoins { relation: TableFactor::Table { name: ObjectName::from(vec![Ident::new("customers".to_string())]), alias: table_alias(true, "c"), args: None, with_hints: vec![], version: None, partitions: vec![], with_ordinality: false, json_path: None, sample: None, index_hints: vec![], }, joins: vec![Join { relation: TableFactor::Table { name: ObjectName::from(vec![Ident::new("products".to_string())]), alias: table_alias(true, "p"), args: None, with_hints: vec![], version: None, partitions: vec![], with_ordinality: false, json_path: None, sample: None, index_hints: vec![], }, global: false, join_operator: JoinOperator::Join(JoinConstraint::On(Expr::BinaryOp { left: Box::new(Expr::CompoundIdentifier(vec![ Ident::new("p".to_string()), Ident::new("customer_id".to_string()) ])), op: BinaryOperator::Eq, right: Box::new(Expr::CompoundIdentifier(vec![ Ident::new("c".to_string()), Ident::new("customer_id".to_string()) ])), })), }] }), alias: None }, global: false, join_operator: JoinOperator::Join(JoinConstraint::On(Expr::BinaryOp { left: Box::new(Expr::CompoundIdentifier(vec![ Ident::new("c".to_string()), Ident::new("order_id".to_string()) ])), op: BinaryOperator::Eq, right: Box::new(Expr::CompoundIdentifier(vec![ Ident::new("o".to_string()), Ident::new("order_id".to_string()) ])), })) }], ); let query = "SELECT DISTINCT p.product_id FROM orders AS o LEFT JOIN customers AS c LEFT JOIN products AS p ON p.customer_id = c.customer_id ON c.order_id = o.order_id"; assert_eq!( only( snowflake() .verified_only_select_with_canonical(query, "SELECT DISTINCT p.product_id FROM orders AS o LEFT JOIN (customers AS c LEFT JOIN products AS p ON p.customer_id = c.customer_id) ON c.order_id = o.order_id") .from ) .joins, vec![Join { relation: TableFactor::NestedJoin { table_with_joins: Box::new(TableWithJoins { relation: TableFactor::Table { name: ObjectName::from(vec![Ident::new("customers".to_string())]), alias: table_alias(true, "c"), args: None, with_hints: vec![], version: None, partitions: vec![], with_ordinality: false, json_path: None, sample: None, index_hints: vec![], }, joins: vec![Join { relation: TableFactor::Table { name: ObjectName::from(vec![Ident::new("products".to_string())]), alias: table_alias(true, "p"), args: None, with_hints: vec![], version: None, partitions: vec![], with_ordinality: false, json_path: None, sample: None, index_hints: vec![], }, global: false, join_operator: JoinOperator::Left(JoinConstraint::On(Expr::BinaryOp { left: Box::new(Expr::CompoundIdentifier(vec![ Ident::new("p".to_string()), Ident::new("customer_id".to_string()) ])), op: BinaryOperator::Eq, right: Box::new(Expr::CompoundIdentifier(vec![ Ident::new("c".to_string()), Ident::new("customer_id".to_string()) ])), })), }] }), alias: None }, global: false, join_operator: JoinOperator::Left(JoinConstraint::On(Expr::BinaryOp { left: Box::new(Expr::CompoundIdentifier(vec![ Ident::new("c".to_string()), Ident::new("order_id".to_string()) ])), op: BinaryOperator::Eq, right: Box::new(Expr::CompoundIdentifier(vec![ Ident::new("o".to_string()), Ident::new("order_id".to_string()) ])), })) }], ); let query = "SELECT DISTINCT p.product_id FROM orders AS o RIGHT JOIN customers AS c RIGHT JOIN products AS p ON p.customer_id = c.customer_id ON c.order_id = o.order_id"; assert_eq!( only( snowflake() .verified_only_select_with_canonical(query, "SELECT DISTINCT p.product_id FROM orders AS o RIGHT JOIN (customers AS c RIGHT JOIN products AS p ON p.customer_id = c.customer_id) ON c.order_id = o.order_id") .from ) .joins, vec![Join { relation: TableFactor::NestedJoin { table_with_joins: Box::new(TableWithJoins { relation: TableFactor::Table { name: ObjectName::from(vec![Ident::new("customers".to_string())]), alias: table_alias(true, "c"), args: None, with_hints: vec![], version: None, partitions: vec![], with_ordinality: false, json_path: None, sample: None, index_hints: vec![], }, joins: vec![Join { relation: TableFactor::Table { name: ObjectName::from(vec![Ident::new("products".to_string())]), alias: table_alias(true, "p"), args: None, with_hints: vec![], version: None, partitions: vec![], with_ordinality: false, json_path: None, sample: None, index_hints: vec![], }, global: false, join_operator: JoinOperator::Right(JoinConstraint::On(Expr::BinaryOp { left: Box::new(Expr::CompoundIdentifier(vec![ Ident::new("p".to_string()), Ident::new("customer_id".to_string()) ])), op: BinaryOperator::Eq, right: Box::new(Expr::CompoundIdentifier(vec![ Ident::new("c".to_string()), Ident::new("customer_id".to_string()) ])), })), }] }), alias: None }, global: false, join_operator: JoinOperator::Right(JoinConstraint::On(Expr::BinaryOp { left: Box::new(Expr::CompoundIdentifier(vec![ Ident::new("c".to_string()), Ident::new("order_id".to_string()) ])), op: BinaryOperator::Eq, right: Box::new(Expr::CompoundIdentifier(vec![ Ident::new("o".to_string()), Ident::new("order_id".to_string()) ])), })) }], ); let query = "SELECT DISTINCT p.product_id FROM orders AS o FULL JOIN customers AS c FULL JOIN products AS p ON p.customer_id = c.customer_id ON c.order_id = o.order_id"; assert_eq!( only( snowflake() .verified_only_select_with_canonical(query, "SELECT DISTINCT p.product_id FROM orders AS o FULL JOIN (customers AS c FULL JOIN products AS p ON p.customer_id = c.customer_id) ON c.order_id = o.order_id") .from ) .joins, vec![Join { relation: TableFactor::NestedJoin { table_with_joins: Box::new(TableWithJoins { relation: TableFactor::Table { name: ObjectName::from(vec![Ident::new("customers".to_string())]), alias: table_alias(true, "c"), args: None, with_hints: vec![], version: None, partitions: vec![], with_ordinality: false, json_path: None, sample: None, index_hints: vec![], }, joins: vec![Join { relation: TableFactor::Table { name: ObjectName::from(vec![Ident::new("products".to_string())]), alias: table_alias(true, "p"), args: None, with_hints: vec![], version: None, partitions: vec![], with_ordinality: false, json_path: None, sample: None, index_hints: vec![], }, global: false, join_operator: JoinOperator::FullOuter(JoinConstraint::On( Expr::BinaryOp { left: Box::new(Expr::CompoundIdentifier(vec![ Ident::new("p".to_string()), Ident::new("customer_id".to_string()) ])), op: BinaryOperator::Eq, right: Box::new(Expr::CompoundIdentifier(vec![ Ident::new("c".to_string()), Ident::new("customer_id".to_string()) ])), } )), }] }), alias: None }, global: false, join_operator: JoinOperator::FullOuter(JoinConstraint::On(Expr::BinaryOp { left: Box::new(Expr::CompoundIdentifier(vec![ Ident::new("c".to_string()), Ident::new("order_id".to_string()) ])), op: BinaryOperator::Eq, right: Box::new(Expr::CompoundIdentifier(vec![ Ident::new("o".to_string()), Ident::new("order_id".to_string()) ])), })) }], ); } #[test] fn parse_connect_by_root_operator() { let sql = "SELECT CONNECT_BY_ROOT name AS root_name FROM Tbl1"; match snowflake().verified_stmt(sql) { Statement::Query(query) => { assert_eq!( query.body.as_select().unwrap().projection[0], SelectItem::ExprWithAlias { expr: Expr::Prefixed { prefix: Ident::new("CONNECT_BY_ROOT"), value: Box::new(Expr::Identifier(Ident::new("name"))) }, alias: Ident::new("root_name"), } ); } _ => unreachable!(), } let sql = "SELECT CONNECT_BY_ROOT name FROM Tbl2"; match snowflake().verified_stmt(sql) { Statement::Query(query) => { assert_eq!( query.body.as_select().unwrap().projection[0], SelectItem::UnnamedExpr(Expr::Prefixed { prefix: Ident::new("CONNECT_BY_ROOT"), value: Box::new(Expr::Identifier(Ident::new("name"))) }) ); } _ => unreachable!(), } let sql = "SELECT CONNECT_BY_ROOT FROM Tbl2"; let res = snowflake().parse_sql_statements(sql); assert_eq!( res.unwrap_err().to_string(), "sql parser error: Expected an expression, found: FROM" ); } #[test] fn test_begin_exception_end() { for sql in [ "BEGIN SELECT 1; EXCEPTION WHEN OTHER THEN SELECT 2; RAISE; END", "BEGIN SELECT 1; EXCEPTION WHEN OTHER THEN SELECT 2; RAISE EX_1; END", "BEGIN SELECT 1; EXCEPTION WHEN FOO THEN SELECT 2; WHEN OTHER THEN SELECT 3; RAISE; END", "BEGIN BEGIN SELECT 1; EXCEPTION WHEN OTHER THEN SELECT 2; RAISE; END; END", ] { snowflake().verified_stmt(sql); } let sql = r#" DECLARE EXCEPTION_1 EXCEPTION (-20001, 'I caught the expected exception.'); EXCEPTION_2 EXCEPTION (-20002, 'Not the expected exception!'); EXCEPTION_3 EXCEPTION (-20003, 'The worst exception...'); BEGIN BEGIN SELECT 1; EXCEPTION WHEN EXCEPTION_1 THEN SELECT 1; WHEN EXCEPTION_2 OR EXCEPTION_3 THEN SELECT 2; SELECT 3; WHEN OTHER THEN SELECT 4; RAISE; END; END "#; // Outer `BEGIN` of the two nested `BEGIN` statements. let Statement::StartTransaction { mut statements, .. } = snowflake() .parse_sql_statements(sql) .unwrap() .pop() .unwrap() else { unreachable!(); }; // Inner `BEGIN` of the two nested `BEGIN` statements. let Statement::StartTransaction { statements, exception, has_end_keyword, .. } = statements.pop().unwrap() else { unreachable!(); }; assert_eq!(1, statements.len()); assert!(has_end_keyword); let exception = exception.unwrap(); assert_eq!(3, exception.len()); assert_eq!(1, exception[0].idents.len()); assert_eq!(1, exception[0].statements.len()); assert_eq!(2, exception[1].idents.len()); assert_eq!(2, exception[1].statements.len()); } #[test] fn test_begin_transaction() { snowflake().verified_stmt("BEGIN TRANSACTION"); snowflake().verified_stmt("BEGIN WORK"); // BEGIN TRANSACTION with statements let stmts = snowflake() .parse_sql_statements("BEGIN TRANSACTION; DROP TABLE IF EXISTS bla; COMMIT") .unwrap(); assert_eq!(3, stmts.len()); // Bare BEGIN (no TRANSACTION keyword) with statements let stmts = snowflake() .parse_sql_statements("BEGIN; DROP TABLE IF EXISTS bla; COMMIT") .unwrap(); assert_eq!(3, stmts.len()); // Bare BEGIN at EOF (no semicolon, no TRANSACTION keyword) snowflake().verified_stmt("BEGIN"); } #[test] fn test_snowflake_fetch_clause_syntax() { let canonical = "SELECT c1 FROM fetch_test FETCH FIRST 2 ROWS ONLY"; snowflake().verified_only_select_with_canonical("SELECT c1 FROM fetch_test FETCH 2", canonical); snowflake() .verified_only_select_with_canonical("SELECT c1 FROM fetch_test FETCH FIRST 2", canonical); snowflake() .verified_only_select_with_canonical("SELECT c1 FROM fetch_test FETCH NEXT 2", canonical); snowflake() .verified_only_select_with_canonical("SELECT c1 FROM fetch_test FETCH 2 ROW", canonical); snowflake().verified_only_select_with_canonical( "SELECT c1 FROM fetch_test FETCH FIRST 2 ROWS", canonical, ); } #[test] fn test_snowflake_create_view_with_multiple_column_options() { let create_view_with_tag = r#"CREATE VIEW X (COL WITH TAG (pii='email') COMMENT 'foobar') AS SELECT * FROM Y"#; snowflake().verified_stmt(create_view_with_tag); } #[test] fn test_snowflake_create_view_with_composite_tag() { let create_view_with_tag = r#"CREATE VIEW X (COL WITH TAG (foo.bar.baz.pii='email')) AS SELECT * FROM Y"#; snowflake().verified_stmt(create_view_with_tag); } #[test] fn test_snowflake_create_view_with_composite_policy_name() { let create_view_with_tag = r#"CREATE VIEW X (COL WITH MASKING POLICY foo.bar.baz) AS SELECT * FROM Y"#; snowflake().verified_stmt(create_view_with_tag); } #[test] fn test_snowflake_create_view_copy_grants() { snowflake().verified_stmt("CREATE OR REPLACE VIEW bla COPY GRANTS AS (SELECT * FROM source)"); snowflake() .verified_stmt("CREATE OR REPLACE SECURE VIEW bla COPY GRANTS AS (SELECT * FROM source)"); // COPY GRANTS with column list snowflake().verified_stmt( "CREATE OR REPLACE VIEW bla COPY GRANTS (a, b) AS (SELECT a, b FROM source)", ); } #[test] fn test_snowflake_identifier_function() { // Using IDENTIFIER to reference a column match &snowflake() .verified_only_select("SELECT identifier('email') FROM customers") .projection[0] { SelectItem::UnnamedExpr(Expr::Function(Function { name, args, .. })) => { assert_eq!(*name, ObjectName::from(vec![Ident::new("identifier")])); assert_eq!( *args, FunctionArguments::List(FunctionArgumentList { args: vec![FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::Value( Value::SingleQuotedString("email".to_string()).into() )))], clauses: vec![], duplicate_treatment: None }) ); } _ => unreachable!(), } // Using IDENTIFIER to reference a case-sensitive column match &snowflake() .verified_only_select(r#"SELECT identifier('"Email"') FROM customers"#) .projection[0] { SelectItem::UnnamedExpr(Expr::Function(Function { name, args, .. })) => { assert_eq!(*name, ObjectName::from(vec![Ident::new("identifier")])); assert_eq!( *args, FunctionArguments::List(FunctionArgumentList { args: vec![FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::Value( Value::SingleQuotedString("\"Email\"".to_string()).into() )))], clauses: vec![], duplicate_treatment: None }) ); } _ => unreachable!(), } // Using IDENTIFIER to reference an alias of a table match &snowflake() .verified_only_select("SELECT identifier('alias1').* FROM tbl AS alias1") .projection[0] { SelectItem::QualifiedWildcard( SelectItemQualifiedWildcardKind::Expr(Expr::Function(Function { name, args, .. })), _, ) => { assert_eq!(*name, ObjectName::from(vec![Ident::new("identifier")])); assert_eq!( *args, FunctionArguments::List(FunctionArgumentList { args: vec![FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::Value( Value::SingleQuotedString("alias1".to_string()).into() )))], clauses: vec![], duplicate_treatment: None }) ); } _ => unreachable!(), } // Using IDENTIFIER to reference a database match snowflake().verified_stmt("CREATE DATABASE IDENTIFIER('tbl')") { Statement::CreateDatabase { db_name, .. } => { assert_eq!( db_name, ObjectName(vec![ObjectNamePart::Function(ObjectNamePartFunction { name: Ident::new("IDENTIFIER"), args: vec![FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::Value( Value::SingleQuotedString("tbl".to_string()).into() )))] })]) ); } _ => unreachable!(), } // Using IDENTIFIER to reference a schema match snowflake().verified_stmt("CREATE SCHEMA IDENTIFIER('db1.sc1')") { Statement::CreateSchema { schema_name, .. } => { assert_eq!( schema_name, SchemaName::Simple(ObjectName(vec![ObjectNamePart::Function( ObjectNamePartFunction { name: Ident::new("IDENTIFIER"), args: vec![FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::Value( Value::SingleQuotedString("db1.sc1".to_string()).into() )))] } )])) ); } _ => unreachable!(), } // Using IDENTIFIER to reference a table match snowflake().verified_stmt("CREATE TABLE IDENTIFIER('tbl') (id INT)") { Statement::CreateTable(CreateTable { name, .. }) => { assert_eq!( name, ObjectName(vec![ObjectNamePart::Function(ObjectNamePartFunction { name: Ident::new("IDENTIFIER"), args: vec![FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::Value( Value::SingleQuotedString("tbl".to_string()).into() )))] })]) ); } _ => unreachable!(), } // Cannot have more than one IDENTIFIER part in an object name assert_eq!( snowflake() .parse_sql_statements( "CREATE TABLE IDENTIFIER('db1').IDENTIFIER('sc1').IDENTIFIER('tbl') (id INT)" ) .is_err(), true ); assert_eq!( snowflake() .parse_sql_statements("CREATE TABLE IDENTIFIER('db1')..IDENTIFIER('tbl') (id INT)") .is_err(), true ); } #[test] fn test_create_database() { snowflake().verified_stmt("CREATE DATABASE my_db"); snowflake().verified_stmt("CREATE OR REPLACE DATABASE my_db"); snowflake().verified_stmt("CREATE TRANSIENT DATABASE IF NOT EXISTS my_db"); snowflake().verified_stmt("CREATE DATABASE my_db CLONE src_db"); snowflake().verified_stmt( "CREATE OR REPLACE DATABASE my_db CLONE src_db DATA_RETENTION_TIME_IN_DAYS = 1", ); snowflake().one_statement_parses_to( r#" CREATE OR REPLACE TRANSIENT DATABASE IF NOT EXISTS my_db CLONE src_db DATA_RETENTION_TIME_IN_DAYS = 1 MAX_DATA_EXTENSION_TIME_IN_DAYS = 5 EXTERNAL_VOLUME = 'volume1' CATALOG = 'my_catalog' REPLACE_INVALID_CHARACTERS = TRUE DEFAULT_DDL_COLLATION = 'en-ci' STORAGE_SERIALIZATION_POLICY = COMPATIBLE COMMENT = 'This is my database' CATALOG_SYNC = 'sync_integration' CATALOG_SYNC_NAMESPACE_MODE = NEST CATALOG_SYNC_NAMESPACE_FLATTEN_DELIMITER = '/' WITH TAG (env = 'prod', team = 'data') WITH CONTACT (owner = 'admin', dpo = 'compliance') "#, "CREATE OR REPLACE TRANSIENT DATABASE IF NOT EXISTS \ my_db CLONE src_db DATA_RETENTION_TIME_IN_DAYS = 1 MAX_DATA_EXTENSION_TIME_IN_DAYS = 5 \ EXTERNAL_VOLUME = 'volume1' CATALOG = 'my_catalog' \ REPLACE_INVALID_CHARACTERS = TRUE DEFAULT_DDL_COLLATION = 'en-ci' \ STORAGE_SERIALIZATION_POLICY = COMPATIBLE COMMENT = 'This is my database' \ CATALOG_SYNC = 'sync_integration' CATALOG_SYNC_NAMESPACE_MODE = NEST \ CATALOG_SYNC_NAMESPACE_FLATTEN_DELIMITER = '/' \ WITH TAG (env='prod', team='data') \ WITH CONTACT (owner = admin, dpo = compliance)", ); let err = snowflake() .parse_sql_statements("CREATE DATABASE") .unwrap_err() .to_string(); assert!(err.contains("Expected"), "Unexpected error: {err}"); let err = snowflake() .parse_sql_statements("CREATE DATABASE my_db CLONE") .unwrap_err() .to_string(); assert!(err.contains("Expected"), "Unexpected error: {err}"); } #[test] fn test_timestamp_ntz_with_precision() { snowflake().verified_stmt("SELECT CAST('2024-01-01 01:00:00' AS TIMESTAMP_NTZ(1))"); snowflake().verified_stmt("SELECT CAST('2024-01-01 01:00:00' AS TIMESTAMP_NTZ(9))"); let select = snowflake().verified_only_select("SELECT CAST('2024-01-01 01:00:00' AS TIMESTAMP_NTZ(9))"); match expr_from_projection(only(&select.projection)) { Expr::Cast { data_type, .. } => { assert_eq!(*data_type, DataType::TimestampNtz(Some(9))); } _ => unreachable!(), } } #[test] fn test_drop_constraints() { snowflake().verified_stmt("ALTER TABLE tbl DROP PRIMARY KEY"); snowflake().verified_stmt("ALTER TABLE tbl DROP FOREIGN KEY k1"); snowflake().verified_stmt("ALTER TABLE tbl DROP CONSTRAINT c1"); snowflake().verified_stmt("ALTER TABLE tbl DROP PRIMARY KEY CASCADE"); snowflake().verified_stmt("ALTER TABLE tbl DROP FOREIGN KEY k1 RESTRICT"); snowflake().verified_stmt("ALTER TABLE tbl DROP CONSTRAINT c1 CASCADE"); } #[test] fn test_alter_dynamic_table() { snowflake().verified_stmt("ALTER DYNAMIC TABLE MY_DYNAMIC_TABLE REFRESH"); snowflake().verified_stmt("ALTER DYNAMIC TABLE my_database.my_schema.my_dynamic_table REFRESH"); snowflake().verified_stmt("ALTER DYNAMIC TABLE my_dyn_table SUSPEND"); snowflake().verified_stmt("ALTER DYNAMIC TABLE my_dyn_table RESUME"); } #[test] fn test_alter_external_table() { snowflake().verified_stmt("ALTER EXTERNAL TABLE some_table REFRESH"); snowflake().verified_stmt("ALTER EXTERNAL TABLE some_table REFRESH 'year=2025/month=12/'"); snowflake().verified_stmt("ALTER EXTERNAL TABLE IF EXISTS some_table REFRESH"); snowflake() .verified_stmt("ALTER EXTERNAL TABLE IF EXISTS some_table REFRESH 'year=2025/month=12/'"); } #[test] fn test_truncate_table_if_exists() { snowflake().verified_stmt("TRUNCATE TABLE IF EXISTS my_table"); snowflake().verified_stmt("TRUNCATE TABLE my_table"); snowflake().verified_stmt("TRUNCATE IF EXISTS my_table"); } #[test] fn test_select_dollar_column_from_stage() { // With table function args and alias snowflake().verified_stmt("SELECT t.$1, t.$2 FROM @mystage1(file_format => 'myformat', pattern => '.*data.*[.]csv.gz') t"); // Without table function args, with alias snowflake().verified_stmt("SELECT t.$1, t.$2 FROM @mystage1 t"); // Without table function args, without alias snowflake().verified_stmt("SELECT $1, $2 FROM @mystage1"); // With table function args, without alias snowflake().verified_stmt("SELECT $1, $2 FROM @mystage1(file_format => 'myformat')"); } apache-datafusion-sqlparser-rs-0.62.0/tests/sqlparser_spark.rs000066400000000000000000000215031517524037000245400ustar00rootroot00000000000000// 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. #![warn(clippy::all)] //! Test SQL syntax specific to Apache Spark SQL. use sqlparser::ast::*; use sqlparser::dialect::SparkSqlDialect; use test_utils::*; #[macro_use] mod test_utils; fn spark() -> TestedDialects { TestedDialects::new(vec![Box::new(SparkSqlDialect {})]) } // -------------------------------- // CREATE TABLE USING // -------------------------------- #[test] fn test_create_table_using() { let stmt = spark().verified_stmt("CREATE TABLE t (i INT, s STRING) USING parquet"); match stmt { Statement::CreateTable(ct) => { assert_eq!(ct.name.to_string(), "t"); assert_eq!(ct.columns.len(), 2); assert_eq!( ct.hive_formats.unwrap().storage, Some(HiveIOFormat::Using { format: Ident::new("parquet") }) ); } _ => panic!("Expected CreateTable"), } } #[test] fn test_create_table_using_if_not_exists() { spark().verified_stmt("CREATE TABLE IF NOT EXISTS t (i INT) USING delta"); } #[test] fn test_create_table_using_with_location() { spark().verified_stmt("CREATE TABLE t (i INT) USING parquet LOCATION '/data/t'"); } #[test] fn test_create_table_multi_column() { spark().verified_stmt( "CREATE TABLE t (i INT, l BIGINT, f FLOAT, d DOUBLE, s STRING, b BOOLEAN) USING parquet", ); } #[test] fn test_create_table_long_type() { // LONG is an alias for BIGINT; round-trips as BIGINT spark().one_statement_parses_to( "CREATE TABLE t (id LONG, val LONG) USING parquet", "CREATE TABLE t (id BIGINT, val BIGINT) USING parquet", ); } #[test] fn test_create_table_array_type() { spark().verified_stmt("CREATE TABLE t (arr ARRAY) USING parquet"); } #[test] fn test_create_table_map_type() { // MAP parses and stores as DataType::Map (which displays as Map(K, V)) spark() .parse_sql_statements("CREATE TABLE t (m MAP) USING parquet") .unwrap(); } #[test] fn test_create_table_struct_type() { // STRUCT field definitions drop the colon separator on round-trip spark().one_statement_parses_to( "CREATE TABLE t (s STRUCT) USING parquet", "CREATE TABLE t (s STRUCT) USING parquet", ); } #[test] fn test_create_table_nested_types() { // Nested types parse successfully spark() .parse_sql_statements( "CREATE TABLE t (arr ARRAY>) USING parquet", ) .unwrap(); spark() .parse_sql_statements("CREATE TABLE t (m MAP, arr ARRAY) USING parquet") .unwrap(); } #[test] fn test_create_table_decimal_type() { spark() .verified_stmt("CREATE TABLE t (grp STRING, d DECIMAL(10,2), flag BOOLEAN) USING parquet"); } // -------------------------------- // INSERT INTO // -------------------------------- #[test] fn test_insert_values() { spark().verified_stmt( "INSERT INTO t VALUES (1, 'a'), (2, 'b'), (3, 'c'), (NULL, 'd'), (1, NULL), (NULL, NULL)", ); } #[test] fn test_insert_values_multiline() { // Multi-line whitespace is normalized to single-line on round-trip spark().one_statement_parses_to( "INSERT INTO t VALUES\n (1, 10, 'a'),\n (2, 20, 'a'),\n (3, 30, 'b')", "INSERT INTO t VALUES (1, 10, 'a'), (2, 20, 'a'), (3, 30, 'b')", ); } // -------------------------------- // Lambda expressions // -------------------------------- #[test] fn test_lambda_single_param() { spark().verified_stmt("SELECT filter(arr, x -> x > 2) FROM t"); } #[test] fn test_lambda_two_params() { spark().verified_stmt("SELECT filter(arr, (x, i) -> i > 0) FROM t"); } #[test] fn test_lambda_transform() { spark().verified_stmt("SELECT transform(arr, x -> x * 2) FROM t"); } // -------------------------------- // DIV integer division // -------------------------------- #[test] fn test_div_operator() { spark().one_statement_parses_to("SELECT c1 div c2 FROM t", "SELECT c1 DIV c2 FROM t"); } #[test] fn test_div_literal() { spark().one_statement_parses_to("SELECT 10 div 3", "SELECT 10 DIV 3"); } // -------------------------------- // Struct support // -------------------------------- #[test] fn test_named_struct() { spark().verified_stmt("SELECT named_struct('x', a, 'y', b, 'z', c) FROM t"); } #[test] fn test_struct_function() { // Parses as a STRUCT literal; round-trips with uppercase STRUCT keyword spark().one_statement_parses_to( "SELECT struct(a, b, c) FROM t", "SELECT STRUCT(a, b, c) FROM t", ); } // -------------------------------- // Aggregate FILTER // -------------------------------- #[test] fn test_aggregate_filter() { spark().verified_stmt( "SELECT COUNT(*) FILTER (WHERE i > 0), SUM(val) FILTER (WHERE val IS NOT NULL) FROM t", ); } #[test] fn test_aggregate_filter_with_group_by() { spark().verified_stmt( "SELECT grp, SUM(i) FILTER (WHERE flag = true) FROM t GROUP BY grp ORDER BY grp", ); } // -------------------------------- // Window functions with IGNORE NULLS // -------------------------------- #[test] fn test_lag_ignore_nulls() { spark().verified_stmt("SELECT LAG(val) IGNORE NULLS OVER (ORDER BY id) AS lag_val FROM t"); } #[test] fn test_lead_ignore_nulls() { spark().verified_stmt( "SELECT LEAD(val) IGNORE NULLS OVER (PARTITION BY grp ORDER BY id) AS lead_val FROM t", ); } #[test] fn test_lag_with_offset_and_default() { spark().verified_stmt("SELECT LAG(val, 2, -1) OVER (ORDER BY id) AS lag_val FROM t"); } // -------------------------------- // CASE WHEN // -------------------------------- #[test] fn test_case_when() { spark().verified_stmt( "SELECT CASE WHEN i = 1 THEN 'one' WHEN i = 2 THEN 'two' ELSE 'other' END FROM t", ); } #[test] fn test_case_value() { spark().verified_stmt("SELECT CASE i WHEN 1 THEN 'one' WHEN 2 THEN 'two' END FROM t"); } // -------------------------------- // CAST expressions // -------------------------------- #[test] fn test_cast_basic_types() { // cast() lower-case round-trips as CAST() upper-case spark().one_statement_parses_to( "SELECT cast(i AS BIGINT), cast(i AS DOUBLE), cast(i AS STRING) FROM t", "SELECT CAST(i AS BIGINT), CAST(i AS DOUBLE), CAST(i AS STRING) FROM t", ); } #[test] fn test_cast_to_timestamp() { spark().one_statement_parses_to( "SELECT cast('2020-01-01' AS TIMESTAMP)", "SELECT CAST('2020-01-01' AS TIMESTAMP)", ); spark().one_statement_parses_to( "SELECT cast('2020-01-01T12:34:56' AS TIMESTAMP)", "SELECT CAST('2020-01-01T12:34:56' AS TIMESTAMP)", ); } #[test] fn test_cast_special_float_values() { spark().one_statement_parses_to( "SELECT cast('NaN' AS FLOAT), cast('Infinity' AS DOUBLE)", "SELECT CAST('NaN' AS FLOAT), CAST('Infinity' AS DOUBLE)", ); } // -------------------------------- // Aggregate functions // -------------------------------- #[test] fn test_count_aggregate() { spark().verified_stmt("SELECT count(*), count(i), count(s) FROM t"); spark().verified_stmt("SELECT grp, count(*), count(i) FROM t GROUP BY grp ORDER BY grp"); } #[test] fn test_sum_avg() { spark().verified_stmt("SELECT avg(i), avg(l), avg(f), avg(d) FROM t"); } #[test] fn test_bit_aggregates() { spark().verified_stmt("SELECT bit_and(i), bit_or(i), bit_xor(i) FROM t"); } // -------------------------------- // Arithmetic // -------------------------------- #[test] fn test_arithmetic_operators() { spark().verified_stmt("SELECT a + b, a - b, a * b, a / b, a % b FROM t"); } #[test] fn test_unary_negative() { spark().verified_stmt("SELECT negative(col1), -(col1) FROM t"); } // -------------------------------- // String operations // -------------------------------- #[test] fn test_like_pattern() { spark().verified_stmt("SELECT s FROM t WHERE s LIKE 'foo%'"); } #[test] fn test_substring() { spark().one_statement_parses_to( "SELECT substring(s, 1, 3) FROM t", "SELECT SUBSTRING(s, 1, 3) FROM t", ); } apache-datafusion-sqlparser-rs-0.62.0/tests/sqlparser_sqlite.rs000066400000000000000000000752051517524037000247310ustar00rootroot00000000000000// 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. #![warn(clippy::all)] //! Test SQL syntax specific to SQLite. The parser based on the //! generic dialect is also tested (on the inputs it can handle). #[macro_use] mod test_utils; use sqlparser::ast::helpers::attached_token::AttachedToken; use sqlparser::keywords::Keyword; use test_utils::*; use sqlparser::ast::SelectItem::UnnamedExpr; use sqlparser::ast::Value::Placeholder; use sqlparser::ast::*; use sqlparser::dialect::{GenericDialect, SQLiteDialect}; use sqlparser::parser::{ParserError, ParserOptions}; use sqlparser::tokenizer::Token; #[test] fn pragma_no_value() { let sql = "PRAGMA cache_size"; match sqlite_and_generic().verified_stmt(sql) { Statement::Pragma { name, value: None, is_eq: false, } => { assert_eq!("cache_size", name.to_string()); } _ => unreachable!(), } } #[test] fn pragma_eq_style() { let sql = "PRAGMA cache_size = 10"; match sqlite_and_generic().verified_stmt(sql) { Statement::Pragma { name, value: Some(val), is_eq: true, } => { assert_eq!("cache_size", name.to_string()); assert_eq!("10", val.to_string()); } _ => unreachable!(), } } #[test] fn pragma_function_style() { let sql = "PRAGMA cache_size(10)"; match sqlite_and_generic().verified_stmt(sql) { Statement::Pragma { name, value: Some(val), is_eq: false, } => { assert_eq!("cache_size", name.to_string()); assert_eq!("10", val.to_string()); } _ => unreachable!(), } } #[test] fn pragma_eq_string_style() { let sql = "PRAGMA table_info = 'sqlite_master'"; match sqlite_and_generic().verified_stmt(sql) { Statement::Pragma { name, value: Some(val), is_eq: true, } => { assert_eq!("table_info", name.to_string()); assert_eq!("'sqlite_master'", val.to_string()); } _ => unreachable!(), } } #[test] fn pragma_function_string_style() { let sql = "PRAGMA table_info(\"sqlite_master\")"; match sqlite_and_generic().verified_stmt(sql) { Statement::Pragma { name, value: Some(val), is_eq: false, } => { assert_eq!("table_info", name.to_string()); assert_eq!("\"sqlite_master\"", val.to_string()); } _ => unreachable!(), } } #[test] fn pragma_eq_placeholder_style() { let sql = "PRAGMA table_info = ?"; match sqlite_and_generic().verified_stmt(sql) { Statement::Pragma { name, value: Some(val), is_eq: true, } => { assert_eq!("table_info", name.to_string()); assert_eq!("?", val.to_string()); } _ => unreachable!(), } } #[test] fn parse_create_table_without_rowid() { let sql = "CREATE TABLE t (a INT) WITHOUT ROWID"; match sqlite_and_generic().verified_stmt(sql) { Statement::CreateTable(CreateTable { name, without_rowid: true, .. }) => { assert_eq!("t", name.to_string()); } _ => unreachable!(), } } #[test] fn parse_create_virtual_table() { let sql = "CREATE VIRTUAL TABLE IF NOT EXISTS t USING module_name (arg1, arg2)"; match sqlite_and_generic().verified_stmt(sql) { Statement::CreateVirtualTable { name, if_not_exists: true, module_name, module_args, } => { let args = vec![Ident::new("arg1"), Ident::new("arg2")]; assert_eq!("t", name.to_string()); assert_eq!("module_name", module_name.to_string()); assert_eq!(args, module_args); } _ => unreachable!(), } let sql = "CREATE VIRTUAL TABLE t USING module_name"; sqlite_and_generic().verified_stmt(sql); } #[test] fn parse_create_view_temporary_if_not_exists() { let sql = "CREATE TEMPORARY VIEW IF NOT EXISTS myschema.myview AS SELECT foo FROM bar"; match sqlite_and_generic().verified_stmt(sql) { Statement::CreateView(CreateView { name, columns, query, or_replace, materialized, options, cluster_by, comment, with_no_schema_binding: late_binding, if_not_exists, temporary, .. }) => { assert_eq!("myschema.myview", name.to_string()); assert_eq!(Vec::::new(), columns); assert_eq!("SELECT foo FROM bar", query.to_string()); assert!(!materialized); assert!(!or_replace); assert_eq!(options, CreateTableOptions::None); assert_eq!(cluster_by, vec![]); assert!(comment.is_none()); assert!(!late_binding); assert!(if_not_exists); assert!(temporary); } _ => unreachable!(), } } #[test] fn double_equality_operator() { // Sqlite supports this operator: https://www.sqlite.org/lang_expr.html#binaryops let input = "SELECT a==b FROM t"; let expected = "SELECT a = b FROM t"; let _ = sqlite_and_generic().one_statement_parses_to(input, expected); } #[test] fn parse_create_table_auto_increment() { let sql = "CREATE TABLE foo (bar INT PRIMARY KEY AUTOINCREMENT)"; match sqlite_and_generic().verified_stmt(sql) { Statement::CreateTable(CreateTable { name, columns, .. }) => { assert_eq!(name.to_string(), "foo"); assert_eq!( vec![ColumnDef { name: "bar".into(), data_type: DataType::Int(None), options: vec![ ColumnOptionDef { name: None, option: ColumnOption::PrimaryKey(PrimaryKeyConstraint { name: None, index_name: None, index_type: None, columns: vec![], index_options: vec![], characteristics: None, }), }, ColumnOptionDef { name: None, option: ColumnOption::DialectSpecific(vec![Token::make_keyword( "AUTOINCREMENT" )]), }, ], }], columns ); } _ => unreachable!(), } } #[test] fn parse_create_table_primary_key_asc_desc() { let expected_column_def = |kind| ColumnDef { name: "bar".into(), data_type: DataType::Int(None), options: vec![ ColumnOptionDef { name: None, option: ColumnOption::PrimaryKey(PrimaryKeyConstraint { name: None, index_name: None, index_type: None, columns: vec![], index_options: vec![], characteristics: None, }), }, ColumnOptionDef { name: None, option: ColumnOption::DialectSpecific(vec![Token::make_keyword(kind)]), }, ], }; let sql = "CREATE TABLE foo (bar INT PRIMARY KEY ASC)"; match sqlite_and_generic().verified_stmt(sql) { Statement::CreateTable(CreateTable { columns, .. }) => { assert_eq!(vec![expected_column_def("ASC")], columns); } _ => unreachable!(), } let sql = "CREATE TABLE foo (bar INT PRIMARY KEY DESC)"; match sqlite_and_generic().verified_stmt(sql) { Statement::CreateTable(CreateTable { columns, .. }) => { assert_eq!(vec![expected_column_def("DESC")], columns); } _ => unreachable!(), } } #[test] fn parse_create_sqlite_quote() { let sql = "CREATE TABLE `PRIMARY` (\"KEY\" INT, [INDEX] INT)"; match sqlite().verified_stmt(sql) { Statement::CreateTable(CreateTable { name, columns, .. }) => { assert_eq!(name.to_string(), "`PRIMARY`"); assert_eq!( vec![ ColumnDef { name: Ident::with_quote('"', "KEY"), data_type: DataType::Int(None), options: vec![], }, ColumnDef { name: Ident::with_quote('[', "INDEX"), data_type: DataType::Int(None), options: vec![], }, ], columns ); } _ => unreachable!(), } } #[test] fn parse_create_table_gencol() { let sql_default = "CREATE TABLE t1 (a INT, b INT GENERATED ALWAYS AS (a * 2))"; sqlite_and_generic().verified_stmt(sql_default); let sql_virt = "CREATE TABLE t1 (a INT, b INT GENERATED ALWAYS AS (a * 2) VIRTUAL)"; sqlite_and_generic().verified_stmt(sql_virt); let sql_stored = "CREATE TABLE t1 (a INT, b INT GENERATED ALWAYS AS (a * 2) STORED)"; sqlite_and_generic().verified_stmt(sql_stored); sqlite_and_generic().verified_stmt("CREATE TABLE t1 (a INT, b INT AS (a * 2))"); sqlite_and_generic().verified_stmt("CREATE TABLE t1 (a INT, b INT AS (a * 2) VIRTUAL)"); sqlite_and_generic().verified_stmt("CREATE TABLE t1 (a INT, b INT AS (a * 2) STORED)"); } #[test] fn parse_create_table_on_conflict_col() { for keyword in [ Keyword::ROLLBACK, Keyword::ABORT, Keyword::FAIL, Keyword::IGNORE, Keyword::REPLACE, ] { 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!( vec![ColumnOptionDef { name: None, option: ColumnOption::OnConflict(keyword), }], columns[1].options ); } _ => unreachable!(), } } } #[test] fn test_parse_create_table_on_conflict_col_err() { let sql_err = "CREATE TABLE t1 (a INT, b INT ON CONFLICT BOH)"; let err = sqlite_and_generic() .parse_sql_statements(sql_err) .unwrap_err(); assert_eq!( err, ParserError::ParserError( "Expected: one of ROLLBACK or ABORT or FAIL or IGNORE or REPLACE, found: BOH" .to_string() ) ); } #[test] fn parse_create_table_untyped() { sqlite().verified_stmt("CREATE TABLE t1 (a, b AS (a * 2), c NOT NULL)"); } #[test] fn test_placeholder() { // In postgres, this would be the absolute value operator '@' applied to the column 'xxx' // But in sqlite, this is a named parameter. // see https://www.sqlite.org/lang_expr.html#varparam let sql = "SELECT @xxx"; let ast = sqlite().verified_only_select(sql); assert_eq!( ast.projection[0], UnnamedExpr(Expr::Value( (Value::Placeholder("@xxx".into())).with_empty_span() )), ); } #[test] fn parse_create_table_with_strict() { let sql = "CREATE TABLE Fruits (id TEXT NOT NULL PRIMARY KEY) STRICT"; if let Statement::CreateTable(CreateTable { name, strict, .. }) = sqlite().verified_stmt(sql) { assert_eq!(name.to_string(), "Fruits"); assert!(strict); } } #[test] fn parse_single_quoted_identified() { sqlite().verified_only_select("SELECT 't'.*, t.'x' FROM 't'"); // TODO: add support for select 't'.x } #[test] fn parse_substring() { // SQLite supports the SUBSTRING function since v3.34, but does not support the SQL standard // SUBSTRING(expr FROM start FOR length) syntax. // https://www.sqlite.org/lang_corefunc.html#substr sqlite().verified_only_select("SELECT SUBSTRING('SQLITE', 3, 4)"); sqlite().verified_only_select("SELECT SUBSTR('SQLITE', 3, 4)"); sqlite().verified_only_select("SELECT SUBSTRING('SQLITE', 3)"); sqlite().verified_only_select("SELECT SUBSTR('SQLITE', 3)"); } #[test] fn parse_window_function_with_filter() { for func_name in [ "row_number", "rank", "max", "count", "user_defined_function", ] { let sql = format!("SELECT {func_name}(x) FILTER (WHERE y) OVER () FROM t"); let select = sqlite().verified_only_select(&sql); assert_eq!(select.to_string(), sql); assert_eq!( select.projection, vec![SelectItem::UnnamedExpr(Expr::Function(Function { name: ObjectName::from(vec![Ident::new(func_name)]), uses_odbc_syntax: false, parameters: FunctionArguments::None, args: FunctionArguments::List(FunctionArgumentList { duplicate_treatment: None, args: vec![FunctionArg::Unnamed(FunctionArgExpr::Expr( Expr::Identifier(Ident::new("x")) ))], clauses: vec![], }), null_treatment: None, over: Some(WindowType::WindowSpec(WindowSpec { window_name: None, partition_by: vec![], order_by: vec![], window_frame: None, })), filter: Some(Box::new(Expr::Identifier(Ident::new("y")))), within_group: vec![], }))] ); } } #[test] 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}")); match verified_stmt { Statement::AttachDatabase { schema_name, database_file_name: Expr::Value(ValueWithSpan { value: Value::SingleQuotedString(literal_name), span: _, }), database: true, } => { assert_eq!(schema_name.value, "test"); assert_eq!(literal_name, "test.db"); } _ => unreachable!(), } } #[test] fn parse_update_tuple_row_values() { // See https://github.com/sqlparser-rs/sqlparser-rs/issues/1311 assert_eq!( sqlite().verified_stmt("UPDATE x SET (a, b) = (1, 2)"), Statement::Update(Update { optimizer_hints: vec![], or: None, assignments: vec![Assignment { target: AssignmentTarget::Tuple(vec![ ObjectName::from(vec![Ident::new("a"),]), ObjectName::from(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()) ]) }], selection: None, table: TableWithJoins { relation: table_from_name(ObjectName::from(vec![Ident::new("x")])), joins: vec![], }, from: None, returning: None, output: None, order_by: vec![], limit: None, update_token: AttachedToken::empty() }) ); } #[test] fn parse_where_in_empty_list() { let sql = "SELECT * FROM t1 WHERE a IN ()"; let select = sqlite().verified_only_select(sql); if let Expr::InList { list, .. } = select.selection.as_ref().unwrap() { assert_eq!(list.len(), 0); } else { unreachable!() } sqlite_with_options(ParserOptions::new().with_trailing_commas(true)).one_statement_parses_to( "SELECT * FROM t1 WHERE a IN (,)", "SELECT * FROM t1 WHERE a IN ()", ); } #[test] fn invalid_empty_list() { let sql = "SELECT * FROM t1 WHERE a IN (,,)"; let sqlite = sqlite_with_options(ParserOptions::new().with_trailing_commas(true)); assert_eq!( "sql parser error: Expected: an expression, found: ,", sqlite.parse_sql_statements(sql).unwrap_err().to_string() ); } #[test] 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"); } #[test] fn test_dollar_identifier_as_placeholder() { // This relates to the discussion in issue #291. The `$id` should be treated as a placeholder, // not as an identifier in SQLite dialect. // // Reference: https://www.sqlite.org/lang_expr.html#varparam match sqlite().verified_expr("id = $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("$id".to_string())).with_empty_span() )) ); } _ => 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+'"#); // Should return an error, not panic assert!(sqlite().parse_sql_statements("SELECT 1 REGEXP").is_err()); assert!(sqlite().parse_sql_statements("SELECT 1 MATCH").is_err()); } #[test] fn test_update_delete_limit() { match sqlite().verified_stmt("UPDATE foo SET bar = 1 LIMIT 99") { Statement::Update(Update { limit, .. }) => { assert_eq!(limit, Some(Expr::value(number("99")))); } _ => unreachable!(), } match sqlite().verified_stmt("DELETE FROM foo LIMIT 99") { Statement::Delete(Delete { limit, .. }) => { assert_eq!(limit, Some(Expr::value(number("99")))); } _ => unreachable!(), } } #[test] fn test_create_trigger() { let statement1 = "CREATE TRIGGER trg_inherit_asset_models AFTER INSERT ON assets FOR EACH ROW BEGIN INSERT INTO users (name) SELECT pam.name FROM users AS pam; END"; match sqlite().verified_stmt(statement1) { Statement::CreateTrigger(CreateTrigger { or_alter, temporary, or_replace, is_constraint, name, period, period_before_table, events, table_name, referenced_table_name, referencing, trigger_object, condition, exec_body: _, statements_as, statements: _, characteristics, }) => { assert!(!or_alter); assert!(!temporary); assert!(!or_replace); assert!(!is_constraint); assert_eq!(name.to_string(), "trg_inherit_asset_models"); assert_eq!(period, Some(TriggerPeriod::After)); assert!(period_before_table); assert_eq!(events, vec![TriggerEvent::Insert]); assert_eq!(table_name.to_string(), "assets"); assert!(referenced_table_name.is_none()); assert!(referencing.is_empty()); assert_eq!( trigger_object, Some(TriggerObjectKind::ForEach(TriggerObject::Row)) ); assert!(condition.is_none()); assert!(!statements_as); assert!(characteristics.is_none()); } _ => unreachable!("Expected CREATE TRIGGER statement"), } // Here we check that the variant of CREATE TRIGGER that omits the `FOR EACH ROW` clause, // which in SQLite may be implicitly assumed, is parsed correctly. let statement2 = "CREATE TRIGGER log_new_user AFTER INSERT ON users BEGIN INSERT INTO user_log (user_id, action, timestamp) VALUES (NEW.id, 'created', datetime('now')); END"; match sqlite().verified_stmt(statement2) { Statement::CreateTrigger(CreateTrigger { or_alter, temporary, or_replace, is_constraint, name, period, period_before_table, events, table_name, referenced_table_name, referencing, trigger_object, condition, exec_body: _, statements_as, statements: _, characteristics, }) => { assert!(!or_alter); assert!(!temporary); assert!(!or_replace); assert!(!is_constraint); assert_eq!(name.to_string(), "log_new_user"); assert_eq!(period, Some(TriggerPeriod::After)); assert!(period_before_table); assert_eq!(events, vec![TriggerEvent::Insert]); assert_eq!(table_name.to_string(), "users"); assert!(referenced_table_name.is_none()); assert!(referencing.is_empty()); assert!(trigger_object.is_none()); assert!(condition.is_none()); assert!(!statements_as); assert!(characteristics.is_none()); } _ => unreachable!("Expected CREATE TRIGGER statement"), } let statement3 = "CREATE TRIGGER cleanup_orders AFTER DELETE ON customers BEGIN DELETE FROM orders WHERE customer_id = OLD.id; DELETE FROM invoices WHERE customer_id = OLD.id; END"; match sqlite().verified_stmt(statement3) { Statement::CreateTrigger(CreateTrigger { or_alter, temporary, or_replace, is_constraint, name, period, period_before_table, events, table_name, referenced_table_name, referencing, trigger_object, condition, exec_body: _, statements_as, statements: _, characteristics, }) => { assert!(!or_alter); assert!(!temporary); assert!(!or_replace); assert!(!is_constraint); assert_eq!(name.to_string(), "cleanup_orders"); assert_eq!(period, Some(TriggerPeriod::After)); assert!(period_before_table); assert_eq!(events, vec![TriggerEvent::Delete]); assert_eq!(table_name.to_string(), "customers"); assert!(referenced_table_name.is_none()); assert!(referencing.is_empty()); assert!(trigger_object.is_none()); assert!(condition.is_none()); assert!(!statements_as); assert!(characteristics.is_none()); } _ => unreachable!("Expected CREATE TRIGGER statement"), } let statement4 = "CREATE TRIGGER trg_before_update BEFORE UPDATE ON products FOR EACH ROW WHEN NEW.price < 0 BEGIN SELECT RAISE(ABORT, 'Price cannot be negative'); END"; match sqlite().verified_stmt(statement4) { Statement::CreateTrigger(CreateTrigger { or_alter, temporary, or_replace, is_constraint, name, period, period_before_table, events, table_name, referenced_table_name, referencing, trigger_object, condition, exec_body: _, statements_as, statements: _, characteristics, }) => { assert!(!or_alter); assert!(!temporary); assert!(!or_replace); assert!(!is_constraint); assert_eq!(name.to_string(), "trg_before_update"); assert_eq!(period, Some(TriggerPeriod::Before)); assert!(period_before_table); assert_eq!(events, vec![TriggerEvent::Update(Vec::new())]); assert_eq!(table_name.to_string(), "products"); assert!(referenced_table_name.is_none()); assert!(referencing.is_empty()); assert_eq!( trigger_object, Some(TriggerObjectKind::ForEach(TriggerObject::Row)) ); assert!(condition.is_some()); assert!(!statements_as); assert!(characteristics.is_none()); } _ => unreachable!("Expected CREATE TRIGGER statement"), } // We test a INSTEAD OF trigger on a view let statement5 = "CREATE TRIGGER trg_instead_of_insert INSTEAD OF INSERT ON my_view BEGIN INSERT INTO my_table (col1, col2) VALUES (NEW.col1, NEW.col2); END"; match sqlite().verified_stmt(statement5) { Statement::CreateTrigger(CreateTrigger { or_alter, temporary, or_replace, is_constraint, name, period, period_before_table, events, table_name, referenced_table_name, referencing, trigger_object, condition, exec_body: _, statements_as, statements: _, characteristics, }) => { assert!(!or_alter); assert!(!temporary); assert!(!or_replace); assert!(!is_constraint); assert_eq!(name.to_string(), "trg_instead_of_insert"); assert_eq!(period, Some(TriggerPeriod::InsteadOf)); assert!(period_before_table); assert_eq!(events, vec![TriggerEvent::Insert]); assert_eq!(table_name.to_string(), "my_view"); assert!(referenced_table_name.is_none()); assert!(referencing.is_empty()); assert!(trigger_object.is_none()); assert!(condition.is_none()); assert!(!statements_as); assert!(characteristics.is_none()); } _ => unreachable!("Expected CREATE TRIGGER statement"), } // We test a temporary trigger let statement6 = "CREATE TEMPORARY TRIGGER temp_trigger AFTER INSERT ON temp_table BEGIN UPDATE log_table SET count = count + 1; END"; match sqlite().verified_stmt(statement6) { Statement::CreateTrigger(CreateTrigger { or_alter, temporary, or_replace, is_constraint, name, period, period_before_table, events, table_name, referenced_table_name, referencing, trigger_object, condition, exec_body: _, statements_as, statements: _, characteristics, }) => { assert!(!or_alter); assert!(temporary); assert!(!or_replace); assert!(!is_constraint); assert_eq!(name.to_string(), "temp_trigger"); assert_eq!(period, Some(TriggerPeriod::After)); assert!(period_before_table); assert_eq!(events, vec![TriggerEvent::Insert]); assert_eq!(table_name.to_string(), "temp_table"); assert!(referenced_table_name.is_none()); assert!(referencing.is_empty()); assert!(trigger_object.is_none()); assert!(condition.is_none()); assert!(!statements_as); assert!(characteristics.is_none()); } _ => unreachable!("Expected CREATE TRIGGER statement"), } // We test a trigger defined without a period (BEFORE/AFTER/INSTEAD OF) let statement7 = "CREATE TRIGGER trg_inherit_asset_models INSERT ON assets FOR EACH ROW BEGIN INSERT INTO users (name) SELECT pam.name FROM users AS pam; END"; sqlite().verified_stmt(statement7); } #[test] fn test_drop_trigger() { let statement = "DROP TRIGGER IF EXISTS trg_inherit_asset_models"; match sqlite().verified_stmt(statement) { Statement::DropTrigger(DropTrigger { if_exists, trigger_name, table_name, option, }) => { assert!(if_exists); assert_eq!(trigger_name.to_string(), "trg_inherit_asset_models"); assert!(table_name.is_none()); assert!(option.is_none()); } _ => unreachable!("Expected DROP TRIGGER statement"), } } fn sqlite() -> TestedDialects { TestedDialects::new(vec![Box::new(SQLiteDialect {})]) } fn sqlite_with_options(options: ParserOptions) -> TestedDialects { TestedDialects::new_with_options(vec![Box::new(SQLiteDialect {})], options) } fn sqlite_and_generic() -> TestedDialects { TestedDialects::new(vec![ Box::new(SQLiteDialect {}), Box::new(GenericDialect {}), ]) } apache-datafusion-sqlparser-rs-0.62.0/tests/sqlparser_teradata.rs000066400000000000000000000042401517524037000252040ustar00rootroot00000000000000// 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. //! Test SQL syntax, specific to [sqlparser::dialect::TeradataDialect]. use sqlparser::dialect::{Dialect, TeradataDialect}; use test_utils::TestedDialects; mod test_utils; fn teradata() -> TestedDialects { TestedDialects::new(vec![Box::new(TeradataDialect)]) } #[test] fn dialect_methods() { let d: &dyn Dialect = &TeradataDialect; assert_eq!(d.identifier_quote_style("x"), Some('"')); assert!(d.is_delimited_identifier_start('"')); assert!(!d.is_delimited_identifier_start('`')); assert!(d.is_identifier_start('$')); assert!(d.is_identifier_start('#')); assert!(d.is_identifier_part('$')); assert!(d.is_identifier_part('#')); assert!(d.supports_group_by_expr()); assert!(!d.supports_boolean_literals()); assert!(d.require_interval_qualifier()); assert!(d.supports_comment_on()); assert!(d.supports_create_table_select()); assert!(d.supports_execute_immediate()); assert!(d.supports_top_before_distinct()); assert!(d.supports_window_function_null_treatment_arg()); assert!(d.supports_string_literal_concatenation()); } #[test] fn parse_identifier() { teradata().verified_stmt(concat!( "SELECT ", "NULL AS foo, ", "NULL AS _bar, ", "NULL AS #baz, ", "NULL AS $qux, ", "NULL AS a$1, ", "NULL AS a#1, ", "NULL AS a_1, ", r#"NULL AS "quoted id""# )); } apache-datafusion-sqlparser-rs-0.62.0/tests/test_utils/000077500000000000000000000000001517524037000231545ustar00rootroot00000000000000apache-datafusion-sqlparser-rs-0.62.0/tests/test_utils/mod.rs000066400000000000000000000032471517524037000243070ustar00rootroot00000000000000// 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. // Re-export everything from `src/test_utils.rs`. pub use sqlparser::test_utils::*; // For the test-only macros we take a different approach of keeping them here // rather than in the library crate. // // This is because we don't need any of them to be shared between the // integration tests (i.e. `tests/*`) and the unit tests (i.e. `src/*`), // but also because Rust doesn't scope macros to a particular module // (and while we export internal helpers as sqlparser::test_utils::<...>, // expecting our users to abstain from relying on them, exporting internal // macros at the top level, like `sqlparser::nest` was deemed too confusing). #[macro_export] macro_rules! nest { ($base:expr $(, $join:expr)*) => { TableFactor::NestedJoin { table_with_joins: Box::new(TableWithJoins { relation: $base, joins: vec![$(join($join)),*] }), alias: None} }; }